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/Hashing.h" 13 #include "llvm/ADT/SmallVector.h" 14 #include "llvm/Support/FormatVariadic.h" 15 #include "llvm/Support/raw_ostream.h" 16 #include "gtest/gtest.h" 17 #include <cmath> 18 #include <ostream> 19 #include <string> 20 #include <tuple> 21 22 using namespace llvm; 23 24 static double convertToDoubleFromString(const char *Str) { 25 llvm::APFloat F(0.0); 26 F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven); 27 return F.convertToDouble(); 28 } 29 30 static std::string convertToString(double d, unsigned Prec, unsigned Pad, 31 bool Tr = true) { 32 llvm::SmallVector<char, 100> Buffer; 33 llvm::APFloat F(d); 34 F.toString(Buffer, Prec, Pad, Tr); 35 return std::string(Buffer.data(), Buffer.size()); 36 } 37 38 namespace { 39 40 TEST(APFloatTest, isSignaling) { 41 // We test qNaN, -qNaN, +sNaN, -sNaN with and without payloads. *NOTE* The 42 // positive/negative distinction is included only since the getQNaN/getSNaN 43 // API provides the option. 44 APInt payload = APInt::getOneBitSet(4, 2); 45 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), false).isSignaling()); 46 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), true).isSignaling()); 47 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), false, &payload).isSignaling()); 48 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle(), true, &payload).isSignaling()); 49 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isSignaling()); 50 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isSignaling()); 51 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false, &payload).isSignaling()); 52 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true, &payload).isSignaling()); 53 } 54 55 TEST(APFloatTest, next) { 56 57 APFloat test(APFloat::IEEEquad(), APFloat::uninitialized); 58 APFloat expected(APFloat::IEEEquad(), APFloat::uninitialized); 59 60 // 1. Test Special Cases Values. 61 // 62 // Test all special values for nextUp and nextDown perscribed by IEEE-754R 63 // 2008. These are: 64 // 1. +inf 65 // 2. -inf 66 // 3. getLargest() 67 // 4. -getLargest() 68 // 5. getSmallest() 69 // 6. -getSmallest() 70 // 7. qNaN 71 // 8. sNaN 72 // 9. +0 73 // 10. -0 74 75 // nextUp(+inf) = +inf. 76 test = APFloat::getInf(APFloat::IEEEquad(), false); 77 expected = APFloat::getInf(APFloat::IEEEquad(), false); 78 EXPECT_EQ(test.next(false), APFloat::opOK); 79 EXPECT_TRUE(test.isInfinity()); 80 EXPECT_TRUE(!test.isNegative()); 81 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 82 83 // nextDown(+inf) = -nextUp(-inf) = -(-getLargest()) = getLargest() 84 test = APFloat::getInf(APFloat::IEEEquad(), false); 85 expected = APFloat::getLargest(APFloat::IEEEquad(), false); 86 EXPECT_EQ(test.next(true), APFloat::opOK); 87 EXPECT_TRUE(!test.isNegative()); 88 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 89 90 // nextUp(-inf) = -getLargest() 91 test = APFloat::getInf(APFloat::IEEEquad(), true); 92 expected = APFloat::getLargest(APFloat::IEEEquad(), true); 93 EXPECT_EQ(test.next(false), APFloat::opOK); 94 EXPECT_TRUE(test.isNegative()); 95 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 96 97 // nextDown(-inf) = -nextUp(+inf) = -(+inf) = -inf. 98 test = APFloat::getInf(APFloat::IEEEquad(), true); 99 expected = APFloat::getInf(APFloat::IEEEquad(), true); 100 EXPECT_EQ(test.next(true), APFloat::opOK); 101 EXPECT_TRUE(test.isInfinity() && test.isNegative()); 102 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 103 104 // nextUp(getLargest()) = +inf 105 test = APFloat::getLargest(APFloat::IEEEquad(), false); 106 expected = APFloat::getInf(APFloat::IEEEquad(), false); 107 EXPECT_EQ(test.next(false), APFloat::opOK); 108 EXPECT_TRUE(test.isInfinity() && !test.isNegative()); 109 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 110 111 // nextDown(getLargest()) = -nextUp(-getLargest()) 112 // = -(-getLargest() + inc) 113 // = getLargest() - inc. 114 test = APFloat::getLargest(APFloat::IEEEquad(), false); 115 expected = APFloat(APFloat::IEEEquad(), 116 "0x1.fffffffffffffffffffffffffffep+16383"); 117 EXPECT_EQ(test.next(true), APFloat::opOK); 118 EXPECT_TRUE(!test.isInfinity() && !test.isNegative()); 119 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 120 121 // nextUp(-getLargest()) = -getLargest() + inc. 122 test = APFloat::getLargest(APFloat::IEEEquad(), true); 123 expected = APFloat(APFloat::IEEEquad(), 124 "-0x1.fffffffffffffffffffffffffffep+16383"); 125 EXPECT_EQ(test.next(false), APFloat::opOK); 126 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 127 128 // nextDown(-getLargest()) = -nextUp(getLargest()) = -(inf) = -inf. 129 test = APFloat::getLargest(APFloat::IEEEquad(), true); 130 expected = APFloat::getInf(APFloat::IEEEquad(), true); 131 EXPECT_EQ(test.next(true), APFloat::opOK); 132 EXPECT_TRUE(test.isInfinity() && test.isNegative()); 133 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 134 135 // nextUp(getSmallest()) = getSmallest() + inc. 136 test = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382"); 137 expected = APFloat(APFloat::IEEEquad(), 138 "0x0.0000000000000000000000000002p-16382"); 139 EXPECT_EQ(test.next(false), APFloat::opOK); 140 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 141 142 // nextDown(getSmallest()) = -nextUp(-getSmallest()) = -(-0) = +0. 143 test = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382"); 144 expected = APFloat::getZero(APFloat::IEEEquad(), false); 145 EXPECT_EQ(test.next(true), APFloat::opOK); 146 EXPECT_TRUE(test.isPosZero()); 147 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 148 149 // nextUp(-getSmallest()) = -0. 150 test = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382"); 151 expected = APFloat::getZero(APFloat::IEEEquad(), true); 152 EXPECT_EQ(test.next(false), APFloat::opOK); 153 EXPECT_TRUE(test.isNegZero()); 154 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 155 156 // nextDown(-getSmallest()) = -nextUp(getSmallest()) = -getSmallest() - inc. 157 test = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382"); 158 expected = APFloat(APFloat::IEEEquad(), 159 "-0x0.0000000000000000000000000002p-16382"); 160 EXPECT_EQ(test.next(true), APFloat::opOK); 161 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 162 163 // nextUp(qNaN) = qNaN 164 test = APFloat::getQNaN(APFloat::IEEEquad(), false); 165 expected = APFloat::getQNaN(APFloat::IEEEquad(), false); 166 EXPECT_EQ(test.next(false), APFloat::opOK); 167 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 168 169 // nextDown(qNaN) = qNaN 170 test = APFloat::getQNaN(APFloat::IEEEquad(), false); 171 expected = APFloat::getQNaN(APFloat::IEEEquad(), false); 172 EXPECT_EQ(test.next(true), APFloat::opOK); 173 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 174 175 // nextUp(sNaN) = qNaN 176 test = APFloat::getSNaN(APFloat::IEEEquad(), false); 177 expected = APFloat::getQNaN(APFloat::IEEEquad(), false); 178 EXPECT_EQ(test.next(false), APFloat::opInvalidOp); 179 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 180 181 // nextDown(sNaN) = qNaN 182 test = APFloat::getSNaN(APFloat::IEEEquad(), false); 183 expected = APFloat::getQNaN(APFloat::IEEEquad(), false); 184 EXPECT_EQ(test.next(true), APFloat::opInvalidOp); 185 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 186 187 // nextUp(+0) = +getSmallest() 188 test = APFloat::getZero(APFloat::IEEEquad(), false); 189 expected = APFloat::getSmallest(APFloat::IEEEquad(), false); 190 EXPECT_EQ(test.next(false), APFloat::opOK); 191 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 192 193 // nextDown(+0) = -nextUp(-0) = -getSmallest() 194 test = APFloat::getZero(APFloat::IEEEquad(), false); 195 expected = APFloat::getSmallest(APFloat::IEEEquad(), true); 196 EXPECT_EQ(test.next(true), APFloat::opOK); 197 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 198 199 // nextUp(-0) = +getSmallest() 200 test = APFloat::getZero(APFloat::IEEEquad(), true); 201 expected = APFloat::getSmallest(APFloat::IEEEquad(), false); 202 EXPECT_EQ(test.next(false), APFloat::opOK); 203 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 204 205 // nextDown(-0) = -nextUp(0) = -getSmallest() 206 test = APFloat::getZero(APFloat::IEEEquad(), true); 207 expected = APFloat::getSmallest(APFloat::IEEEquad(), true); 208 EXPECT_EQ(test.next(true), APFloat::opOK); 209 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 210 211 // 2. Binade Boundary Tests. 212 213 // 2a. Test denormal <-> normal binade boundaries. 214 // * nextUp(+Largest Denormal) -> +Smallest Normal. 215 // * nextDown(-Largest Denormal) -> -Smallest Normal. 216 // * nextUp(-Smallest Normal) -> -Largest Denormal. 217 // * nextDown(+Smallest Normal) -> +Largest Denormal. 218 219 // nextUp(+Largest Denormal) -> +Smallest Normal. 220 test = APFloat(APFloat::IEEEquad(), "0x0.ffffffffffffffffffffffffffffp-16382"); 221 expected = APFloat(APFloat::IEEEquad(), 222 "0x1.0000000000000000000000000000p-16382"); 223 EXPECT_EQ(test.next(false), APFloat::opOK); 224 EXPECT_FALSE(test.isDenormal()); 225 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 226 227 // nextDown(-Largest Denormal) -> -Smallest Normal. 228 test = APFloat(APFloat::IEEEquad(), 229 "-0x0.ffffffffffffffffffffffffffffp-16382"); 230 expected = APFloat(APFloat::IEEEquad(), 231 "-0x1.0000000000000000000000000000p-16382"); 232 EXPECT_EQ(test.next(true), APFloat::opOK); 233 EXPECT_FALSE(test.isDenormal()); 234 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 235 236 // nextUp(-Smallest Normal) -> -LargestDenormal. 237 test = APFloat(APFloat::IEEEquad(), 238 "-0x1.0000000000000000000000000000p-16382"); 239 expected = APFloat(APFloat::IEEEquad(), 240 "-0x0.ffffffffffffffffffffffffffffp-16382"); 241 EXPECT_EQ(test.next(false), APFloat::opOK); 242 EXPECT_TRUE(test.isDenormal()); 243 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 244 245 // nextDown(+Smallest Normal) -> +Largest Denormal. 246 test = APFloat(APFloat::IEEEquad(), 247 "+0x1.0000000000000000000000000000p-16382"); 248 expected = APFloat(APFloat::IEEEquad(), 249 "+0x0.ffffffffffffffffffffffffffffp-16382"); 250 EXPECT_EQ(test.next(true), APFloat::opOK); 251 EXPECT_TRUE(test.isDenormal()); 252 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 253 254 // 2b. Test normal <-> normal binade boundaries. 255 // * nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1. 256 // * nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1. 257 // * nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary. 258 // * nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary. 259 260 // nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1. 261 test = APFloat(APFloat::IEEEquad(), "-0x1p+1"); 262 expected = APFloat(APFloat::IEEEquad(), 263 "-0x1.ffffffffffffffffffffffffffffp+0"); 264 EXPECT_EQ(test.next(false), APFloat::opOK); 265 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 266 267 // nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1. 268 test = APFloat(APFloat::IEEEquad(), "0x1p+1"); 269 expected = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp+0"); 270 EXPECT_EQ(test.next(true), APFloat::opOK); 271 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 272 273 // nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary. 274 test = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp+0"); 275 expected = APFloat(APFloat::IEEEquad(), "0x1p+1"); 276 EXPECT_EQ(test.next(false), APFloat::opOK); 277 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 278 279 // nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary. 280 test = APFloat(APFloat::IEEEquad(), "-0x1.ffffffffffffffffffffffffffffp+0"); 281 expected = APFloat(APFloat::IEEEquad(), "-0x1p+1"); 282 EXPECT_EQ(test.next(true), APFloat::opOK); 283 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 284 285 // 2c. Test using next at binade boundaries with a direction away from the 286 // binade boundary. Away from denormal <-> normal boundaries. 287 // 288 // This is to make sure that even though we are at a binade boundary, since 289 // we are rounding away, we do not trigger the binade boundary code. Thus we 290 // test: 291 // * nextUp(-Largest Denormal) -> -Largest Denormal + inc. 292 // * nextDown(+Largest Denormal) -> +Largest Denormal - inc. 293 // * nextUp(+Smallest Normal) -> +Smallest Normal + inc. 294 // * nextDown(-Smallest Normal) -> -Smallest Normal - inc. 295 296 // nextUp(-Largest Denormal) -> -Largest Denormal + inc. 297 test = APFloat(APFloat::IEEEquad(), "-0x0.ffffffffffffffffffffffffffffp-16382"); 298 expected = APFloat(APFloat::IEEEquad(), 299 "-0x0.fffffffffffffffffffffffffffep-16382"); 300 EXPECT_EQ(test.next(false), APFloat::opOK); 301 EXPECT_TRUE(test.isDenormal()); 302 EXPECT_TRUE(test.isNegative()); 303 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 304 305 // nextDown(+Largest Denormal) -> +Largest Denormal - inc. 306 test = APFloat(APFloat::IEEEquad(), "0x0.ffffffffffffffffffffffffffffp-16382"); 307 expected = APFloat(APFloat::IEEEquad(), 308 "0x0.fffffffffffffffffffffffffffep-16382"); 309 EXPECT_EQ(test.next(true), APFloat::opOK); 310 EXPECT_TRUE(test.isDenormal()); 311 EXPECT_TRUE(!test.isNegative()); 312 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 313 314 // nextUp(+Smallest Normal) -> +Smallest Normal + inc. 315 test = APFloat(APFloat::IEEEquad(), "0x1.0000000000000000000000000000p-16382"); 316 expected = APFloat(APFloat::IEEEquad(), 317 "0x1.0000000000000000000000000001p-16382"); 318 EXPECT_EQ(test.next(false), APFloat::opOK); 319 EXPECT_TRUE(!test.isDenormal()); 320 EXPECT_TRUE(!test.isNegative()); 321 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 322 323 // nextDown(-Smallest Normal) -> -Smallest Normal - inc. 324 test = APFloat(APFloat::IEEEquad(), "-0x1.0000000000000000000000000000p-16382"); 325 expected = APFloat(APFloat::IEEEquad(), 326 "-0x1.0000000000000000000000000001p-16382"); 327 EXPECT_EQ(test.next(true), APFloat::opOK); 328 EXPECT_TRUE(!test.isDenormal()); 329 EXPECT_TRUE(test.isNegative()); 330 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 331 332 // 2d. Test values which cause our exponent to go to min exponent. This 333 // is to ensure that guards in the code to check for min exponent 334 // trigger properly. 335 // * nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382 336 // * nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) -> 337 // -0x1p-16381 338 // * nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16382 339 // * nextDown(0x1p-16382) -> 0x1.ffffffffffffffffffffffffffffp-16382 340 341 // nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382 342 test = APFloat(APFloat::IEEEquad(), "-0x1p-16381"); 343 expected = APFloat(APFloat::IEEEquad(), 344 "-0x1.ffffffffffffffffffffffffffffp-16382"); 345 EXPECT_EQ(test.next(false), APFloat::opOK); 346 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 347 348 // nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) -> 349 // -0x1p-16381 350 test = APFloat(APFloat::IEEEquad(), "-0x1.ffffffffffffffffffffffffffffp-16382"); 351 expected = APFloat(APFloat::IEEEquad(), "-0x1p-16381"); 352 EXPECT_EQ(test.next(true), APFloat::opOK); 353 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 354 355 // nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16381 356 test = APFloat(APFloat::IEEEquad(), "0x1.ffffffffffffffffffffffffffffp-16382"); 357 expected = APFloat(APFloat::IEEEquad(), "0x1p-16381"); 358 EXPECT_EQ(test.next(false), APFloat::opOK); 359 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 360 361 // nextDown(0x1p-16381) -> 0x1.ffffffffffffffffffffffffffffp-16382 362 test = APFloat(APFloat::IEEEquad(), "0x1p-16381"); 363 expected = APFloat(APFloat::IEEEquad(), 364 "0x1.ffffffffffffffffffffffffffffp-16382"); 365 EXPECT_EQ(test.next(true), APFloat::opOK); 366 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 367 368 // 3. Now we test both denormal/normal computation which will not cause us 369 // to go across binade boundaries. Specifically we test: 370 // * nextUp(+Denormal) -> +Denormal. 371 // * nextDown(+Denormal) -> +Denormal. 372 // * nextUp(-Denormal) -> -Denormal. 373 // * nextDown(-Denormal) -> -Denormal. 374 // * nextUp(+Normal) -> +Normal. 375 // * nextDown(+Normal) -> +Normal. 376 // * nextUp(-Normal) -> -Normal. 377 // * nextDown(-Normal) -> -Normal. 378 379 // nextUp(+Denormal) -> +Denormal. 380 test = APFloat(APFloat::IEEEquad(), 381 "0x0.ffffffffffffffffffffffff000cp-16382"); 382 expected = APFloat(APFloat::IEEEquad(), 383 "0x0.ffffffffffffffffffffffff000dp-16382"); 384 EXPECT_EQ(test.next(false), APFloat::opOK); 385 EXPECT_TRUE(test.isDenormal()); 386 EXPECT_TRUE(!test.isNegative()); 387 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 388 389 // nextDown(+Denormal) -> +Denormal. 390 test = APFloat(APFloat::IEEEquad(), 391 "0x0.ffffffffffffffffffffffff000cp-16382"); 392 expected = APFloat(APFloat::IEEEquad(), 393 "0x0.ffffffffffffffffffffffff000bp-16382"); 394 EXPECT_EQ(test.next(true), APFloat::opOK); 395 EXPECT_TRUE(test.isDenormal()); 396 EXPECT_TRUE(!test.isNegative()); 397 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 398 399 // nextUp(-Denormal) -> -Denormal. 400 test = APFloat(APFloat::IEEEquad(), 401 "-0x0.ffffffffffffffffffffffff000cp-16382"); 402 expected = APFloat(APFloat::IEEEquad(), 403 "-0x0.ffffffffffffffffffffffff000bp-16382"); 404 EXPECT_EQ(test.next(false), APFloat::opOK); 405 EXPECT_TRUE(test.isDenormal()); 406 EXPECT_TRUE(test.isNegative()); 407 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 408 409 // nextDown(-Denormal) -> -Denormal 410 test = APFloat(APFloat::IEEEquad(), 411 "-0x0.ffffffffffffffffffffffff000cp-16382"); 412 expected = APFloat(APFloat::IEEEquad(), 413 "-0x0.ffffffffffffffffffffffff000dp-16382"); 414 EXPECT_EQ(test.next(true), APFloat::opOK); 415 EXPECT_TRUE(test.isDenormal()); 416 EXPECT_TRUE(test.isNegative()); 417 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 418 419 // nextUp(+Normal) -> +Normal. 420 test = APFloat(APFloat::IEEEquad(), 421 "0x1.ffffffffffffffffffffffff000cp-16000"); 422 expected = APFloat(APFloat::IEEEquad(), 423 "0x1.ffffffffffffffffffffffff000dp-16000"); 424 EXPECT_EQ(test.next(false), APFloat::opOK); 425 EXPECT_TRUE(!test.isDenormal()); 426 EXPECT_TRUE(!test.isNegative()); 427 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 428 429 // nextDown(+Normal) -> +Normal. 430 test = APFloat(APFloat::IEEEquad(), 431 "0x1.ffffffffffffffffffffffff000cp-16000"); 432 expected = APFloat(APFloat::IEEEquad(), 433 "0x1.ffffffffffffffffffffffff000bp-16000"); 434 EXPECT_EQ(test.next(true), APFloat::opOK); 435 EXPECT_TRUE(!test.isDenormal()); 436 EXPECT_TRUE(!test.isNegative()); 437 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 438 439 // nextUp(-Normal) -> -Normal. 440 test = APFloat(APFloat::IEEEquad(), 441 "-0x1.ffffffffffffffffffffffff000cp-16000"); 442 expected = APFloat(APFloat::IEEEquad(), 443 "-0x1.ffffffffffffffffffffffff000bp-16000"); 444 EXPECT_EQ(test.next(false), APFloat::opOK); 445 EXPECT_TRUE(!test.isDenormal()); 446 EXPECT_TRUE(test.isNegative()); 447 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 448 449 // nextDown(-Normal) -> -Normal. 450 test = APFloat(APFloat::IEEEquad(), 451 "-0x1.ffffffffffffffffffffffff000cp-16000"); 452 expected = APFloat(APFloat::IEEEquad(), 453 "-0x1.ffffffffffffffffffffffff000dp-16000"); 454 EXPECT_EQ(test.next(true), APFloat::opOK); 455 EXPECT_TRUE(!test.isDenormal()); 456 EXPECT_TRUE(test.isNegative()); 457 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 458 } 459 460 TEST(APFloatTest, FMA) { 461 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven; 462 463 { 464 APFloat f1(14.5f); 465 APFloat f2(-14.5f); 466 APFloat f3(225.0f); 467 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven); 468 EXPECT_EQ(14.75f, f1.convertToFloat()); 469 } 470 471 { 472 APFloat Val2(2.0f); 473 APFloat f1((float)1.17549435e-38F); 474 APFloat f2((float)1.17549435e-38F); 475 f1.divide(Val2, rdmd); 476 f2.divide(Val2, rdmd); 477 APFloat f3(12.0f); 478 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven); 479 EXPECT_EQ(12.0f, f1.convertToFloat()); 480 } 481 482 // Test for correct zero sign when answer is exactly zero. 483 // fma(1.0, -1.0, 1.0) -> +ve 0. 484 { 485 APFloat f1(1.0); 486 APFloat f2(-1.0); 487 APFloat f3(1.0); 488 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven); 489 EXPECT_TRUE(!f1.isNegative() && f1.isZero()); 490 } 491 492 // Test for correct zero sign when answer is exactly zero and rounding towards 493 // negative. 494 // fma(1.0, -1.0, 1.0) -> +ve 0. 495 { 496 APFloat f1(1.0); 497 APFloat f2(-1.0); 498 APFloat f3(1.0); 499 f1.fusedMultiplyAdd(f2, f3, APFloat::rmTowardNegative); 500 EXPECT_TRUE(f1.isNegative() && f1.isZero()); 501 } 502 503 // Test for correct (in this case -ve) sign when adding like signed zeros. 504 // Test fma(0.0, -0.0, -0.0) -> -ve 0. 505 { 506 APFloat f1(0.0); 507 APFloat f2(-0.0); 508 APFloat f3(-0.0); 509 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven); 510 EXPECT_TRUE(f1.isNegative() && f1.isZero()); 511 } 512 513 // Test -ve sign preservation when small negative results underflow. 514 { 515 APFloat f1(APFloat::IEEEdouble(), "-0x1p-1074"); 516 APFloat f2(APFloat::IEEEdouble(), "+0x1p-1074"); 517 APFloat f3(0.0); 518 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven); 519 EXPECT_TRUE(f1.isNegative() && f1.isZero()); 520 } 521 522 // Test x87 extended precision case from http://llvm.org/PR20728. 523 { 524 APFloat M1(APFloat::x87DoubleExtended(), 1.0); 525 APFloat M2(APFloat::x87DoubleExtended(), 1.0); 526 APFloat A(APFloat::x87DoubleExtended(), 3.0); 527 528 bool losesInfo = false; 529 M1.fusedMultiplyAdd(M1, A, APFloat::rmNearestTiesToEven); 530 M1.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo); 531 EXPECT_FALSE(losesInfo); 532 EXPECT_EQ(4.0f, M1.convertToFloat()); 533 } 534 } 535 536 TEST(APFloatTest, MinNum) { 537 APFloat f1(1.0); 538 APFloat f2(2.0); 539 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble()); 540 541 EXPECT_EQ(1.0, minnum(f1, f2).convertToDouble()); 542 EXPECT_EQ(1.0, minnum(f2, f1).convertToDouble()); 543 EXPECT_EQ(1.0, minnum(f1, nan).convertToDouble()); 544 EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble()); 545 } 546 547 TEST(APFloatTest, MaxNum) { 548 APFloat f1(1.0); 549 APFloat f2(2.0); 550 APFloat nan = APFloat::getNaN(APFloat::IEEEdouble()); 551 552 EXPECT_EQ(2.0, maxnum(f1, f2).convertToDouble()); 553 EXPECT_EQ(2.0, maxnum(f2, f1).convertToDouble()); 554 EXPECT_EQ(1.0, maxnum(f1, nan).convertToDouble()); 555 EXPECT_EQ(1.0, maxnum(nan, f1).convertToDouble()); 556 } 557 558 TEST(APFloatTest, Denormal) { 559 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven; 560 561 // Test single precision 562 { 563 const char *MinNormalStr = "1.17549435082228750797e-38"; 564 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), MinNormalStr).isDenormal()); 565 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), 0.0).isDenormal()); 566 567 APFloat Val2(APFloat::IEEEsingle(), 2.0e0); 568 APFloat T(APFloat::IEEEsingle(), MinNormalStr); 569 T.divide(Val2, rdmd); 570 EXPECT_TRUE(T.isDenormal()); 571 } 572 573 // Test double precision 574 { 575 const char *MinNormalStr = "2.22507385850720138309e-308"; 576 EXPECT_FALSE(APFloat(APFloat::IEEEdouble(), MinNormalStr).isDenormal()); 577 EXPECT_FALSE(APFloat(APFloat::IEEEdouble(), 0.0).isDenormal()); 578 579 APFloat Val2(APFloat::IEEEdouble(), 2.0e0); 580 APFloat T(APFloat::IEEEdouble(), MinNormalStr); 581 T.divide(Val2, rdmd); 582 EXPECT_TRUE(T.isDenormal()); 583 } 584 585 // Test Intel double-ext 586 { 587 const char *MinNormalStr = "3.36210314311209350626e-4932"; 588 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended(), MinNormalStr).isDenormal()); 589 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended(), 0.0).isDenormal()); 590 591 APFloat Val2(APFloat::x87DoubleExtended(), 2.0e0); 592 APFloat T(APFloat::x87DoubleExtended(), MinNormalStr); 593 T.divide(Val2, rdmd); 594 EXPECT_TRUE(T.isDenormal()); 595 } 596 597 // Test quadruple precision 598 { 599 const char *MinNormalStr = "3.36210314311209350626267781732175260e-4932"; 600 EXPECT_FALSE(APFloat(APFloat::IEEEquad(), MinNormalStr).isDenormal()); 601 EXPECT_FALSE(APFloat(APFloat::IEEEquad(), 0.0).isDenormal()); 602 603 APFloat Val2(APFloat::IEEEquad(), 2.0e0); 604 APFloat T(APFloat::IEEEquad(), MinNormalStr); 605 T.divide(Val2, rdmd); 606 EXPECT_TRUE(T.isDenormal()); 607 } 608 } 609 610 TEST(APFloatTest, Zero) { 611 EXPECT_EQ(0.0f, APFloat(0.0f).convertToFloat()); 612 EXPECT_EQ(-0.0f, APFloat(-0.0f).convertToFloat()); 613 EXPECT_TRUE(APFloat(-0.0f).isNegative()); 614 615 EXPECT_EQ(0.0, APFloat(0.0).convertToDouble()); 616 EXPECT_EQ(-0.0, APFloat(-0.0).convertToDouble()); 617 EXPECT_TRUE(APFloat(-0.0).isNegative()); 618 } 619 620 TEST(APFloatTest, DecimalStringsWithoutNullTerminators) { 621 // Make sure that we can parse strings without null terminators. 622 // rdar://14323230. 623 APFloat Val(APFloat::IEEEdouble()); 624 Val.convertFromString(StringRef("0.00", 3), 625 llvm::APFloat::rmNearestTiesToEven); 626 EXPECT_EQ(Val.convertToDouble(), 0.0); 627 Val.convertFromString(StringRef("0.01", 3), 628 llvm::APFloat::rmNearestTiesToEven); 629 EXPECT_EQ(Val.convertToDouble(), 0.0); 630 Val.convertFromString(StringRef("0.09", 3), 631 llvm::APFloat::rmNearestTiesToEven); 632 EXPECT_EQ(Val.convertToDouble(), 0.0); 633 Val.convertFromString(StringRef("0.095", 4), 634 llvm::APFloat::rmNearestTiesToEven); 635 EXPECT_EQ(Val.convertToDouble(), 0.09); 636 Val.convertFromString(StringRef("0.00e+3", 7), 637 llvm::APFloat::rmNearestTiesToEven); 638 EXPECT_EQ(Val.convertToDouble(), 0.00); 639 Val.convertFromString(StringRef("0e+3", 4), 640 llvm::APFloat::rmNearestTiesToEven); 641 EXPECT_EQ(Val.convertToDouble(), 0.00); 642 643 } 644 645 TEST(APFloatTest, fromZeroDecimalString) { 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").convertToDouble()); 655 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0").convertToDouble()); 656 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0").convertToDouble()); 657 658 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0").convertToDouble()); 659 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0").convertToDouble()); 660 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0").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(), ".00000").convertToDouble()); 667 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.00000").convertToDouble()); 668 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.00000").convertToDouble()); 669 670 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0000.00000").convertToDouble()); 671 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0000.00000").convertToDouble()); 672 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0000.00000").convertToDouble()); 673 } 674 675 TEST(APFloatTest, fromZeroDecimalSingleExponentString) { 676 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e1").convertToDouble()); 677 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e1").convertToDouble()); 678 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e1").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 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e-1").convertToDouble()); 685 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e-1").convertToDouble()); 686 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1").convertToDouble()); 687 688 689 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.e1").convertToDouble()); 690 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e1").convertToDouble()); 691 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e1").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(), "0.e-1").convertToDouble()); 698 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.e-1").convertToDouble()); 699 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.e-1").convertToDouble()); 700 701 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e1").convertToDouble()); 702 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e1").convertToDouble()); 703 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e1").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 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), ".0e-1").convertToDouble()); 710 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+.0e-1").convertToDouble()); 711 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-.0e-1").convertToDouble()); 712 713 714 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e1").convertToDouble()); 715 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e1").convertToDouble()); 716 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e1").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 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0.0e-1").convertToDouble()); 723 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0.0e-1").convertToDouble()); 724 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0.0e-1").convertToDouble()); 725 726 727 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "000.0000e1").convertToDouble()); 728 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+000.0000e+1").convertToDouble()); 729 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-000.0000e+1").convertToDouble()); 730 } 731 732 TEST(APFloatTest, fromZeroDecimalLargeExponentString) { 733 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0e1234").convertToDouble()); 734 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e1234").convertToDouble()); 735 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e1234").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(), "0e-1234").convertToDouble()); 742 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0e-1234").convertToDouble()); 743 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0e-1234").convertToDouble()); 744 745 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), "000.0000e1234").convertToDouble()); 746 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), "000.0000e-1234").convertToDouble()); 747 748 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble(), StringRef("0e1234" "\0" "2", 6)).convertToDouble()); 749 } 750 751 TEST(APFloatTest, fromZeroHexadecimalString) { 752 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p1").convertToDouble()); 753 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p1").convertToDouble()); 754 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1").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 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p-1").convertToDouble()); 761 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0p-1").convertToDouble()); 762 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p-1").convertToDouble()); 763 764 765 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1").convertToDouble()); 766 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p1").convertToDouble()); 767 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p1").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 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p-1").convertToDouble()); 774 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.p-1").convertToDouble()); 775 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.p-1").convertToDouble()); 776 777 778 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p1").convertToDouble()); 779 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p1").convertToDouble()); 780 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p1").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 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.0p-1").convertToDouble()); 787 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x.0p-1").convertToDouble()); 788 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x.0p-1").convertToDouble()); 789 790 791 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p1").convertToDouble()); 792 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p1").convertToDouble()); 793 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p1").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 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.0p-1").convertToDouble()); 800 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble(), "+0x0.0p-1").convertToDouble()); 801 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0.0p-1").convertToDouble()); 802 803 804 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1").convertToDouble()); 805 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1").convertToDouble()); 806 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1").convertToDouble()); 807 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1").convertToDouble()); 808 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0p1234").convertToDouble()); 809 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble(), "-0x0p1234").convertToDouble()); 810 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x00000.p1234").convertToDouble()); 811 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0000.00000p1234").convertToDouble()); 812 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x.00000p1234").convertToDouble()); 813 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble(), "0x0.p1234").convertToDouble()); 814 } 815 816 TEST(APFloatTest, fromDecimalString) { 817 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1").convertToDouble()); 818 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble(), "2.").convertToDouble()); 819 EXPECT_EQ(0.5, APFloat(APFloat::IEEEdouble(), ".5").convertToDouble()); 820 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "1.0").convertToDouble()); 821 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-2").convertToDouble()); 822 EXPECT_EQ(-4.0, APFloat(APFloat::IEEEdouble(), "-4.").convertToDouble()); 823 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-.5").convertToDouble()); 824 EXPECT_EQ(-1.5, APFloat(APFloat::IEEEdouble(), "-1.5").convertToDouble()); 825 EXPECT_EQ(1.25e12, APFloat(APFloat::IEEEdouble(), "1.25e12").convertToDouble()); 826 EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble(), "1.25e+12").convertToDouble()); 827 EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble(), "1.25e-12").convertToDouble()); 828 EXPECT_EQ(1024.0, APFloat(APFloat::IEEEdouble(), "1024.").convertToDouble()); 829 EXPECT_EQ(1024.05, APFloat(APFloat::IEEEdouble(), "1024.05000").convertToDouble()); 830 EXPECT_EQ(0.05, APFloat(APFloat::IEEEdouble(), ".05000").convertToDouble()); 831 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble(), "2.").convertToDouble()); 832 EXPECT_EQ(2.0e2, APFloat(APFloat::IEEEdouble(), "2.e2").convertToDouble()); 833 EXPECT_EQ(2.0e+2, APFloat(APFloat::IEEEdouble(), "2.e+2").convertToDouble()); 834 EXPECT_EQ(2.0e-2, APFloat(APFloat::IEEEdouble(), "2.e-2").convertToDouble()); 835 EXPECT_EQ(2.05e2, APFloat(APFloat::IEEEdouble(), "002.05000e2").convertToDouble()); 836 EXPECT_EQ(2.05e+2, APFloat(APFloat::IEEEdouble(), "002.05000e+2").convertToDouble()); 837 EXPECT_EQ(2.05e-2, APFloat(APFloat::IEEEdouble(), "002.05000e-2").convertToDouble()); 838 EXPECT_EQ(2.05e12, APFloat(APFloat::IEEEdouble(), "002.05000e12").convertToDouble()); 839 EXPECT_EQ(2.05e+12, APFloat(APFloat::IEEEdouble(), "002.05000e+12").convertToDouble()); 840 EXPECT_EQ(2.05e-12, APFloat(APFloat::IEEEdouble(), "002.05000e-12").convertToDouble()); 841 842 // These are "carefully selected" to overflow the fast log-base 843 // calculations in APFloat.cpp 844 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "99e99999").isInfinity()); 845 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-99e99999").isInfinity()); 846 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "1e-99999").isPosZero()); 847 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-1e-99999").isNegZero()); 848 849 EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828")); 850 } 851 852 TEST(APFloatTest, fromToStringSpecials) { 853 auto expects = [] (const char *first, const char *second) { 854 std::string roundtrip = convertToString(convertToDoubleFromString(second), 0, 3); 855 EXPECT_STREQ(first, roundtrip.c_str()); 856 }; 857 expects("+Inf", "+Inf"); 858 expects("+Inf", "INFINITY"); 859 expects("+Inf", "inf"); 860 expects("-Inf", "-Inf"); 861 expects("-Inf", "-INFINITY"); 862 expects("-Inf", "-inf"); 863 expects("NaN", "NaN"); 864 expects("NaN", "nan"); 865 expects("NaN", "-NaN"); 866 expects("NaN", "-nan"); 867 } 868 869 TEST(APFloatTest, fromHexadecimalString) { 870 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble()); 871 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p0").convertToDouble()); 872 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p0").convertToDouble()); 873 874 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p+0").convertToDouble()); 875 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p+0").convertToDouble()); 876 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p+0").convertToDouble()); 877 878 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p-0").convertToDouble()); 879 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p-0").convertToDouble()); 880 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p-0").convertToDouble()); 881 882 883 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p1").convertToDouble()); 884 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p1").convertToDouble()); 885 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p1").convertToDouble()); 886 887 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p+1").convertToDouble()); 888 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p+1").convertToDouble()); 889 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p+1").convertToDouble()); 890 891 EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble(), "0x1p-1").convertToDouble()); 892 EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble(), "+0x1p-1").convertToDouble()); 893 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-0x1p-1").convertToDouble()); 894 895 896 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p1").convertToDouble()); 897 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p1").convertToDouble()); 898 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p1").convertToDouble()); 899 900 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p+1").convertToDouble()); 901 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p+1").convertToDouble()); 902 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p+1").convertToDouble()); 903 904 EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble(), "0x1.8p-1").convertToDouble()); 905 EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble(), "+0x1.8p-1").convertToDouble()); 906 EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble(), "-0x1.8p-1").convertToDouble()); 907 908 909 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p1").convertToDouble()); 910 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p1").convertToDouble()); 911 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p1").convertToDouble()); 912 913 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p+1").convertToDouble()); 914 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p+1").convertToDouble()); 915 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p+1").convertToDouble()); 916 917 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p-1").convertToDouble()); 918 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p-1").convertToDouble()); 919 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p-1").convertToDouble()); 920 921 922 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p1").convertToDouble()); 923 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p1").convertToDouble()); 924 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p1").convertToDouble()); 925 926 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p+1").convertToDouble()); 927 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p+1").convertToDouble()); 928 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p+1").convertToDouble()); 929 930 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(), "0x1000p-1").convertToDouble()); 931 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000p-1").convertToDouble()); 932 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000p-1").convertToDouble()); 933 934 935 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p10").convertToDouble()); 936 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p10").convertToDouble()); 937 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p10").convertToDouble()); 938 939 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p+10").convertToDouble()); 940 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p+10").convertToDouble()); 941 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p+10").convertToDouble()); 942 943 EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble(), "0x10p-10").convertToDouble()); 944 EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble(), "+0x10p-10").convertToDouble()); 945 EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble(), "-0x10p-10").convertToDouble()); 946 947 EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble(), "0x1.1p0").convertToDouble()); 948 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble()); 949 950 EXPECT_EQ(convertToDoubleFromString("0x1p-150"), 951 convertToDoubleFromString("+0x800000000000000001.p-221")); 952 EXPECT_EQ(2251799813685248.5, 953 convertToDoubleFromString("0x80000000000004000000.010p-28")); 954 } 955 956 TEST(APFloatTest, toString) { 957 ASSERT_EQ("10", convertToString(10.0, 6, 3)); 958 ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0)); 959 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2)); 960 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2)); 961 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1)); 962 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2)); 963 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2)); 964 ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1)); 965 ASSERT_EQ("0.78539816339744828", convertToString(0.78539816339744830961, 0, 3)); 966 ASSERT_EQ("4.9406564584124654E-324", convertToString(4.9406564584124654e-324, 0, 3)); 967 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1)); 968 ASSERT_EQ("8.7318340000000001E+2", convertToString(873.1834, 0, 0)); 969 ASSERT_EQ("1.7976931348623157E+308", convertToString(1.7976931348623157E+308, 0, 0)); 970 ASSERT_EQ("10", convertToString(10.0, 6, 3, false)); 971 ASSERT_EQ("1.000000e+01", convertToString(10.0, 6, 0, false)); 972 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2, false)); 973 ASSERT_EQ("1.0100e+04", convertToString(1.01E+4, 4, 2, false)); 974 ASSERT_EQ("1.01000e+04", convertToString(1.01E+4, 5, 1, false)); 975 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2, false)); 976 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2, false)); 977 ASSERT_EQ("1.01000e-02", convertToString(1.01E-2, 5, 1, false)); 978 ASSERT_EQ("0.78539816339744828", 979 convertToString(0.78539816339744830961, 0, 3, false)); 980 ASSERT_EQ("4.94065645841246540e-324", 981 convertToString(4.9406564584124654e-324, 0, 3, false)); 982 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1, false)); 983 ASSERT_EQ("8.73183400000000010e+02", convertToString(873.1834, 0, 0, false)); 984 ASSERT_EQ("1.79769313486231570e+308", 985 convertToString(1.7976931348623157E+308, 0, 0, false)); 986 } 987 988 TEST(APFloatTest, toInteger) { 989 bool isExact = false; 990 APSInt result(5, /*isUnsigned=*/true); 991 992 EXPECT_EQ(APFloat::opOK, 993 APFloat(APFloat::IEEEdouble(), "10") 994 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 995 EXPECT_TRUE(isExact); 996 EXPECT_EQ(APSInt(APInt(5, 10), true), result); 997 998 EXPECT_EQ(APFloat::opInvalidOp, 999 APFloat(APFloat::IEEEdouble(), "-10") 1000 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 1001 EXPECT_FALSE(isExact); 1002 EXPECT_EQ(APSInt::getMinValue(5, true), result); 1003 1004 EXPECT_EQ(APFloat::opInvalidOp, 1005 APFloat(APFloat::IEEEdouble(), "32") 1006 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 1007 EXPECT_FALSE(isExact); 1008 EXPECT_EQ(APSInt::getMaxValue(5, true), result); 1009 1010 EXPECT_EQ(APFloat::opInexact, 1011 APFloat(APFloat::IEEEdouble(), "7.9") 1012 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 1013 EXPECT_FALSE(isExact); 1014 EXPECT_EQ(APSInt(APInt(5, 7), true), result); 1015 1016 result.setIsUnsigned(false); 1017 EXPECT_EQ(APFloat::opOK, 1018 APFloat(APFloat::IEEEdouble(), "-10") 1019 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 1020 EXPECT_TRUE(isExact); 1021 EXPECT_EQ(APSInt(APInt(5, -10, true), false), result); 1022 1023 EXPECT_EQ(APFloat::opInvalidOp, 1024 APFloat(APFloat::IEEEdouble(), "-17") 1025 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 1026 EXPECT_FALSE(isExact); 1027 EXPECT_EQ(APSInt::getMinValue(5, false), result); 1028 1029 EXPECT_EQ(APFloat::opInvalidOp, 1030 APFloat(APFloat::IEEEdouble(), "16") 1031 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 1032 EXPECT_FALSE(isExact); 1033 EXPECT_EQ(APSInt::getMaxValue(5, false), result); 1034 } 1035 1036 static APInt nanbits(const fltSemantics &Sem, 1037 bool SNaN, bool Negative, uint64_t fill) { 1038 APInt apfill(64, fill); 1039 if (SNaN) 1040 return APFloat::getSNaN(Sem, Negative, &apfill).bitcastToAPInt(); 1041 else 1042 return APFloat::getQNaN(Sem, Negative, &apfill).bitcastToAPInt(); 1043 } 1044 1045 TEST(APFloatTest, makeNaN) { 1046 ASSERT_EQ(0x7fc00000, nanbits(APFloat::IEEEsingle(), false, false, 0)); 1047 ASSERT_EQ(0xffc00000, nanbits(APFloat::IEEEsingle(), false, true, 0)); 1048 ASSERT_EQ(0x7fc0ae72, nanbits(APFloat::IEEEsingle(), false, false, 0xae72)); 1049 ASSERT_EQ(0x7fffae72, nanbits(APFloat::IEEEsingle(), false, false, 0xffffae72)); 1050 ASSERT_EQ(0x7fa00000, nanbits(APFloat::IEEEsingle(), true, false, 0)); 1051 ASSERT_EQ(0xffa00000, nanbits(APFloat::IEEEsingle(), true, true, 0)); 1052 ASSERT_EQ(0x7f80ae72, nanbits(APFloat::IEEEsingle(), true, false, 0xae72)); 1053 ASSERT_EQ(0x7fbfae72, nanbits(APFloat::IEEEsingle(), true, false, 0xffffae72)); 1054 1055 ASSERT_EQ(0x7ff8000000000000ULL, nanbits(APFloat::IEEEdouble(), false, false, 0)); 1056 ASSERT_EQ(0xfff8000000000000ULL, nanbits(APFloat::IEEEdouble(), false, true, 0)); 1057 ASSERT_EQ(0x7ff800000000ae72ULL, nanbits(APFloat::IEEEdouble(), false, false, 0xae72)); 1058 ASSERT_EQ(0x7fffffffffffae72ULL, nanbits(APFloat::IEEEdouble(), false, false, 0xffffffffffffae72ULL)); 1059 ASSERT_EQ(0x7ff4000000000000ULL, nanbits(APFloat::IEEEdouble(), true, false, 0)); 1060 ASSERT_EQ(0xfff4000000000000ULL, nanbits(APFloat::IEEEdouble(), true, true, 0)); 1061 ASSERT_EQ(0x7ff000000000ae72ULL, nanbits(APFloat::IEEEdouble(), true, false, 0xae72)); 1062 ASSERT_EQ(0x7ff7ffffffffae72ULL, nanbits(APFloat::IEEEdouble(), true, false, 0xffffffffffffae72ULL)); 1063 } 1064 1065 #ifdef GTEST_HAS_DEATH_TEST 1066 #ifndef NDEBUG 1067 TEST(APFloatTest, SemanticsDeath) { 1068 EXPECT_DEATH(APFloat(APFloat::IEEEsingle(), 0.0f).convertToDouble(), "Float semantics are not IEEEdouble"); 1069 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), 0.0 ).convertToFloat(), "Float semantics are not IEEEsingle"); 1070 } 1071 1072 TEST(APFloatTest, StringDecimalDeath) { 1073 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ""), "Invalid string length"); 1074 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+"), "String has no digits"); 1075 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-"), "String has no digits"); 1076 1077 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("\0", 1)), "Invalid character in significand"); 1078 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1\0", 2)), "Invalid character in significand"); 1079 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1" "\0" "2", 3)), "Invalid character in significand"); 1080 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1" "\0" "2e1", 5)), "Invalid character in significand"); 1081 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1e\0", 3)), "Invalid character in exponent"); 1082 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1e1\0", 4)), "Invalid character in exponent"); 1083 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("1e1" "\0" "2", 5)), "Invalid character in exponent"); 1084 1085 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0f"), "Invalid character in significand"); 1086 1087 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".."), "String contains multiple dots"); 1088 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "..0"), "String contains multiple dots"); 1089 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0.0"), "String contains multiple dots"); 1090 } 1091 1092 TEST(APFloatTest, StringDecimalSignificandDeath) { 1093 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "."), "Significand has no digits"); 1094 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+."), "Significand has no digits"); 1095 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-."), "Significand has no digits"); 1096 1097 1098 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "e"), "Significand has no digits"); 1099 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+e"), "Significand has no digits"); 1100 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-e"), "Significand has no digits"); 1101 1102 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "e1"), "Significand has no digits"); 1103 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+e1"), "Significand has no digits"); 1104 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-e1"), "Significand has no digits"); 1105 1106 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".e1"), "Significand has no digits"); 1107 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+.e1"), "Significand has no digits"); 1108 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-.e1"), "Significand has no digits"); 1109 1110 1111 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".e"), "Significand has no digits"); 1112 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+.e"), "Significand has no digits"); 1113 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-.e"), "Significand has no digits"); 1114 } 1115 1116 TEST(APFloatTest, StringDecimalExponentDeath) { 1117 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1e"), "Exponent has no digits"); 1118 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+1e"), "Exponent has no digits"); 1119 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-1e"), "Exponent has no digits"); 1120 1121 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.e"), "Exponent has no digits"); 1122 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+1.e"), "Exponent has no digits"); 1123 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-1.e"), "Exponent has no digits"); 1124 1125 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".1e"), "Exponent has no digits"); 1126 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+.1e"), "Exponent has no digits"); 1127 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-.1e"), "Exponent has no digits"); 1128 1129 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.1e"), "Exponent has no digits"); 1130 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+1.1e"), "Exponent has no digits"); 1131 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-1.1e"), "Exponent has no digits"); 1132 1133 1134 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1e+"), "Exponent has no digits"); 1135 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1e-"), "Exponent has no digits"); 1136 1137 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".1e"), "Exponent has no digits"); 1138 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".1e+"), "Exponent has no digits"); 1139 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), ".1e-"), "Exponent has no digits"); 1140 1141 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0e"), "Exponent has no digits"); 1142 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0e+"), "Exponent has no digits"); 1143 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "1.0e-"), "Exponent has no digits"); 1144 } 1145 1146 TEST(APFloatTest, StringHexadecimalDeath) { 1147 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x"), "Invalid string"); 1148 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x"), "Invalid string"); 1149 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x"), "Invalid string"); 1150 1151 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x0"), "Hex strings require an exponent"); 1152 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x0"), "Hex strings require an exponent"); 1153 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x0"), "Hex strings require an exponent"); 1154 1155 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x0."), "Hex strings require an exponent"); 1156 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x0."), "Hex strings require an exponent"); 1157 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x0."), "Hex strings require an exponent"); 1158 1159 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x.0"), "Hex strings require an exponent"); 1160 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.0"), "Hex strings require an exponent"); 1161 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.0"), "Hex strings require an exponent"); 1162 1163 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x0.0"), "Hex strings require an exponent"); 1164 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x0.0"), "Hex strings require an exponent"); 1165 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x0.0"), "Hex strings require an exponent"); 1166 1167 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x\0", 3)), "Invalid character in significand"); 1168 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1\0", 4)), "Invalid character in significand"); 1169 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1" "\0" "2", 5)), "Invalid character in significand"); 1170 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1" "\0" "2p1", 7)), "Invalid character in significand"); 1171 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1p\0", 5)), "Invalid character in exponent"); 1172 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1p1\0", 6)), "Invalid character in exponent"); 1173 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), StringRef("0x1p1" "\0" "2", 7)), "Invalid character in exponent"); 1174 1175 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1p0f"), "Invalid character in exponent"); 1176 1177 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x..p1"), "String contains multiple dots"); 1178 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x..0p1"), "String contains multiple dots"); 1179 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1.0.0p1"), "String contains multiple dots"); 1180 } 1181 1182 TEST(APFloatTest, StringHexadecimalSignificandDeath) { 1183 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x."), "Significand has no digits"); 1184 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x."), "Significand has no digits"); 1185 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x."), "Significand has no digits"); 1186 1187 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0xp"), "Significand has no digits"); 1188 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0xp"), "Significand has no digits"); 1189 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0xp"), "Significand has no digits"); 1190 1191 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0xp+"), "Significand has no digits"); 1192 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0xp+"), "Significand has no digits"); 1193 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0xp+"), "Significand has no digits"); 1194 1195 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0xp-"), "Significand has no digits"); 1196 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0xp-"), "Significand has no digits"); 1197 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0xp-"), "Significand has no digits"); 1198 1199 1200 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x.p"), "Significand has no digits"); 1201 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.p"), "Significand has no digits"); 1202 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.p"), "Significand has no digits"); 1203 1204 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x.p+"), "Significand has no digits"); 1205 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.p+"), "Significand has no digits"); 1206 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.p+"), "Significand has no digits"); 1207 1208 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x.p-"), "Significand has no digits"); 1209 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.p-"), "Significand has no digits"); 1210 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.p-"), "Significand has no digits"); 1211 } 1212 1213 TEST(APFloatTest, StringHexadecimalExponentDeath) { 1214 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1p"), "Exponent has no digits"); 1215 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1p"), "Exponent has no digits"); 1216 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1p"), "Exponent has no digits"); 1217 1218 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1p+"), "Exponent has no digits"); 1219 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1p+"), "Exponent has no digits"); 1220 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1p+"), "Exponent has no digits"); 1221 1222 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1p-"), "Exponent has no digits"); 1223 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1p-"), "Exponent has no digits"); 1224 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1p-"), "Exponent has no digits"); 1225 1226 1227 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1.p"), "Exponent has no digits"); 1228 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.p"), "Exponent has no digits"); 1229 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.p"), "Exponent has no digits"); 1230 1231 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1.p+"), "Exponent has no digits"); 1232 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.p+"), "Exponent has no digits"); 1233 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.p+"), "Exponent has no digits"); 1234 1235 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1.p-"), "Exponent has no digits"); 1236 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.p-"), "Exponent has no digits"); 1237 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.p-"), "Exponent has no digits"); 1238 1239 1240 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x.1p"), "Exponent has no digits"); 1241 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.1p"), "Exponent has no digits"); 1242 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.1p"), "Exponent has no digits"); 1243 1244 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x.1p+"), "Exponent has no digits"); 1245 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.1p+"), "Exponent has no digits"); 1246 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.1p+"), "Exponent has no digits"); 1247 1248 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x.1p-"), "Exponent has no digits"); 1249 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x.1p-"), "Exponent has no digits"); 1250 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x.1p-"), "Exponent has no digits"); 1251 1252 1253 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1.1p"), "Exponent has no digits"); 1254 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.1p"), "Exponent has no digits"); 1255 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.1p"), "Exponent has no digits"); 1256 1257 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1.1p+"), "Exponent has no digits"); 1258 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.1p+"), "Exponent has no digits"); 1259 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.1p+"), "Exponent has no digits"); 1260 1261 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "0x1.1p-"), "Exponent has no digits"); 1262 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "+0x1.1p-"), "Exponent has no digits"); 1263 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), "-0x1.1p-"), "Exponent has no digits"); 1264 } 1265 #endif 1266 #endif 1267 1268 TEST(APFloatTest, exactInverse) { 1269 APFloat inv(0.0f); 1270 1271 // Trivial operation. 1272 EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv)); 1273 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5))); 1274 EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv)); 1275 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f))); 1276 EXPECT_TRUE(APFloat(APFloat::IEEEquad(), "2.0").getExactInverse(&inv)); 1277 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad(), "0.5"))); 1278 EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble(), "2.0").getExactInverse(&inv)); 1279 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble(), "0.5"))); 1280 EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended(), "2.0").getExactInverse(&inv)); 1281 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended(), "0.5"))); 1282 1283 // FLT_MIN 1284 EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv)); 1285 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f))); 1286 1287 // Large float, inverse is a denormal. 1288 EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(nullptr)); 1289 // Zero 1290 EXPECT_FALSE(APFloat(0.0).getExactInverse(nullptr)); 1291 // Denormalized float 1292 EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(nullptr)); 1293 } 1294 1295 TEST(APFloatTest, roundToIntegral) { 1296 APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble())), P(0.0); 1297 1298 P = T; 1299 P.roundToIntegral(APFloat::rmTowardZero); 1300 EXPECT_EQ(-0.0, P.convertToDouble()); 1301 P = T; 1302 P.roundToIntegral(APFloat::rmTowardNegative); 1303 EXPECT_EQ(-1.0, P.convertToDouble()); 1304 P = T; 1305 P.roundToIntegral(APFloat::rmTowardPositive); 1306 EXPECT_EQ(-0.0, P.convertToDouble()); 1307 P = T; 1308 P.roundToIntegral(APFloat::rmNearestTiesToEven); 1309 EXPECT_EQ(-0.0, P.convertToDouble()); 1310 1311 P = S; 1312 P.roundToIntegral(APFloat::rmTowardZero); 1313 EXPECT_EQ(3.0, P.convertToDouble()); 1314 P = S; 1315 P.roundToIntegral(APFloat::rmTowardNegative); 1316 EXPECT_EQ(3.0, P.convertToDouble()); 1317 P = S; 1318 P.roundToIntegral(APFloat::rmTowardPositive); 1319 EXPECT_EQ(4.0, P.convertToDouble()); 1320 P = S; 1321 P.roundToIntegral(APFloat::rmNearestTiesToEven); 1322 EXPECT_EQ(3.0, P.convertToDouble()); 1323 1324 P = R; 1325 P.roundToIntegral(APFloat::rmTowardZero); 1326 EXPECT_EQ(R.convertToDouble(), P.convertToDouble()); 1327 P = R; 1328 P.roundToIntegral(APFloat::rmTowardNegative); 1329 EXPECT_EQ(R.convertToDouble(), P.convertToDouble()); 1330 P = R; 1331 P.roundToIntegral(APFloat::rmTowardPositive); 1332 EXPECT_EQ(R.convertToDouble(), P.convertToDouble()); 1333 P = R; 1334 P.roundToIntegral(APFloat::rmNearestTiesToEven); 1335 EXPECT_EQ(R.convertToDouble(), P.convertToDouble()); 1336 1337 P = APFloat::getZero(APFloat::IEEEdouble()); 1338 P.roundToIntegral(APFloat::rmTowardZero); 1339 EXPECT_EQ(0.0, P.convertToDouble()); 1340 P = APFloat::getZero(APFloat::IEEEdouble(), true); 1341 P.roundToIntegral(APFloat::rmTowardZero); 1342 EXPECT_EQ(-0.0, P.convertToDouble()); 1343 P = APFloat::getNaN(APFloat::IEEEdouble()); 1344 P.roundToIntegral(APFloat::rmTowardZero); 1345 EXPECT_TRUE(std::isnan(P.convertToDouble())); 1346 P = APFloat::getInf(APFloat::IEEEdouble()); 1347 P.roundToIntegral(APFloat::rmTowardZero); 1348 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() > 0.0); 1349 P = APFloat::getInf(APFloat::IEEEdouble(), true); 1350 P.roundToIntegral(APFloat::rmTowardZero); 1351 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() < 0.0); 1352 } 1353 1354 TEST(APFloatTest, isInteger) { 1355 APFloat T(-0.0); 1356 EXPECT_TRUE(T.isInteger()); 1357 T = APFloat(3.14159); 1358 EXPECT_FALSE(T.isInteger()); 1359 T = APFloat::getNaN(APFloat::IEEEdouble()); 1360 EXPECT_FALSE(T.isInteger()); 1361 T = APFloat::getInf(APFloat::IEEEdouble()); 1362 EXPECT_FALSE(T.isInteger()); 1363 T = APFloat::getInf(APFloat::IEEEdouble(), true); 1364 EXPECT_FALSE(T.isInteger()); 1365 T = APFloat::getLargest(APFloat::IEEEdouble()); 1366 EXPECT_TRUE(T.isInteger()); 1367 } 1368 1369 TEST(DoubleAPFloatTest, isInteger) { 1370 APFloat F1(-0.0); 1371 APFloat F2(-0.0); 1372 llvm::detail::DoubleAPFloat T(APFloat::PPCDoubleDouble(), std::move(F1), 1373 std::move(F2)); 1374 EXPECT_TRUE(T.isInteger()); 1375 APFloat F3(3.14159); 1376 APFloat F4(-0.0); 1377 llvm::detail::DoubleAPFloat T2(APFloat::PPCDoubleDouble(), std::move(F3), 1378 std::move(F4)); 1379 EXPECT_FALSE(T2.isInteger()); 1380 APFloat F5(-0.0); 1381 APFloat F6(3.14159); 1382 llvm::detail::DoubleAPFloat T3(APFloat::PPCDoubleDouble(), std::move(F5), 1383 std::move(F6)); 1384 EXPECT_FALSE(T3.isInteger()); 1385 } 1386 1387 TEST(APFloatTest, getLargest) { 1388 EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle()).convertToFloat()); 1389 EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble()).convertToDouble()); 1390 } 1391 1392 TEST(APFloatTest, getSmallest) { 1393 APFloat test = APFloat::getSmallest(APFloat::IEEEsingle(), false); 1394 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x0.000002p-126"); 1395 EXPECT_FALSE(test.isNegative()); 1396 EXPECT_TRUE(test.isFiniteNonZero()); 1397 EXPECT_TRUE(test.isDenormal()); 1398 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1399 1400 test = APFloat::getSmallest(APFloat::IEEEsingle(), true); 1401 expected = APFloat(APFloat::IEEEsingle(), "-0x0.000002p-126"); 1402 EXPECT_TRUE(test.isNegative()); 1403 EXPECT_TRUE(test.isFiniteNonZero()); 1404 EXPECT_TRUE(test.isDenormal()); 1405 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1406 1407 test = APFloat::getSmallest(APFloat::IEEEquad(), false); 1408 expected = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382"); 1409 EXPECT_FALSE(test.isNegative()); 1410 EXPECT_TRUE(test.isFiniteNonZero()); 1411 EXPECT_TRUE(test.isDenormal()); 1412 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1413 1414 test = APFloat::getSmallest(APFloat::IEEEquad(), true); 1415 expected = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382"); 1416 EXPECT_TRUE(test.isNegative()); 1417 EXPECT_TRUE(test.isFiniteNonZero()); 1418 EXPECT_TRUE(test.isDenormal()); 1419 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1420 } 1421 1422 TEST(APFloatTest, getSmallestNormalized) { 1423 APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false); 1424 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x1p-126"); 1425 EXPECT_FALSE(test.isNegative()); 1426 EXPECT_TRUE(test.isFiniteNonZero()); 1427 EXPECT_FALSE(test.isDenormal()); 1428 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1429 1430 test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true); 1431 expected = APFloat(APFloat::IEEEsingle(), "-0x1p-126"); 1432 EXPECT_TRUE(test.isNegative()); 1433 EXPECT_TRUE(test.isFiniteNonZero()); 1434 EXPECT_FALSE(test.isDenormal()); 1435 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1436 1437 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), false); 1438 expected = APFloat(APFloat::IEEEquad(), "0x1p-16382"); 1439 EXPECT_FALSE(test.isNegative()); 1440 EXPECT_TRUE(test.isFiniteNonZero()); 1441 EXPECT_FALSE(test.isDenormal()); 1442 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1443 1444 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), true); 1445 expected = APFloat(APFloat::IEEEquad(), "-0x1p-16382"); 1446 EXPECT_TRUE(test.isNegative()); 1447 EXPECT_TRUE(test.isFiniteNonZero()); 1448 EXPECT_FALSE(test.isDenormal()); 1449 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1450 } 1451 1452 TEST(APFloatTest, getZero) { 1453 struct { 1454 const fltSemantics *semantics; 1455 const bool sign; 1456 const unsigned long long bitPattern[2]; 1457 const unsigned bitPatternLength; 1458 } const GetZeroTest[] = { 1459 { &APFloat::IEEEhalf(), false, {0, 0}, 1}, 1460 { &APFloat::IEEEhalf(), true, {0x8000ULL, 0}, 1}, 1461 { &APFloat::IEEEsingle(), false, {0, 0}, 1}, 1462 { &APFloat::IEEEsingle(), true, {0x80000000ULL, 0}, 1}, 1463 { &APFloat::IEEEdouble(), false, {0, 0}, 1}, 1464 { &APFloat::IEEEdouble(), true, {0x8000000000000000ULL, 0}, 1}, 1465 { &APFloat::IEEEquad(), false, {0, 0}, 2}, 1466 { &APFloat::IEEEquad(), true, {0, 0x8000000000000000ULL}, 2}, 1467 { &APFloat::PPCDoubleDouble(), false, {0, 0}, 2}, 1468 { &APFloat::PPCDoubleDouble(), true, {0x8000000000000000ULL, 0}, 2}, 1469 { &APFloat::x87DoubleExtended(), false, {0, 0}, 2}, 1470 { &APFloat::x87DoubleExtended(), true, {0, 0x8000ULL}, 2}, 1471 }; 1472 const unsigned NumGetZeroTests = 12; 1473 for (unsigned i = 0; i < NumGetZeroTests; ++i) { 1474 APFloat test = APFloat::getZero(*GetZeroTest[i].semantics, 1475 GetZeroTest[i].sign); 1476 const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0"; 1477 APFloat expected = APFloat(*GetZeroTest[i].semantics, 1478 pattern); 1479 EXPECT_TRUE(test.isZero()); 1480 EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative()); 1481 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1482 for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) { 1483 EXPECT_EQ(GetZeroTest[i].bitPattern[j], 1484 test.bitcastToAPInt().getRawData()[j]); 1485 } 1486 } 1487 } 1488 1489 TEST(APFloatTest, copySign) { 1490 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual( 1491 APFloat::copySign(APFloat(42.0), APFloat(-1.0)))); 1492 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual( 1493 APFloat::copySign(APFloat(-42.0), APFloat(1.0)))); 1494 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual( 1495 APFloat::copySign(APFloat(-42.0), APFloat(-1.0)))); 1496 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual( 1497 APFloat::copySign(APFloat(42.0), APFloat(1.0)))); 1498 } 1499 1500 TEST(APFloatTest, convert) { 1501 bool losesInfo; 1502 APFloat test(APFloat::IEEEdouble(), "1.0"); 1503 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo); 1504 EXPECT_EQ(1.0f, test.convertToFloat()); 1505 EXPECT_FALSE(losesInfo); 1506 1507 test = APFloat(APFloat::x87DoubleExtended(), "0x1p-53"); 1508 test.add(APFloat(APFloat::x87DoubleExtended(), "1.0"), APFloat::rmNearestTiesToEven); 1509 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo); 1510 EXPECT_EQ(1.0, test.convertToDouble()); 1511 EXPECT_TRUE(losesInfo); 1512 1513 test = APFloat(APFloat::IEEEquad(), "0x1p-53"); 1514 test.add(APFloat(APFloat::IEEEquad(), "1.0"), APFloat::rmNearestTiesToEven); 1515 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo); 1516 EXPECT_EQ(1.0, test.convertToDouble()); 1517 EXPECT_TRUE(losesInfo); 1518 1519 test = APFloat(APFloat::x87DoubleExtended(), "0xf.fffffffp+28"); 1520 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo); 1521 EXPECT_EQ(4294967295.0, test.convertToDouble()); 1522 EXPECT_FALSE(losesInfo); 1523 1524 test = APFloat::getSNaN(APFloat::IEEEsingle()); 1525 APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended()); 1526 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven, 1527 &losesInfo); 1528 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN)); 1529 EXPECT_FALSE(losesInfo); 1530 1531 test = APFloat::getQNaN(APFloat::IEEEsingle()); 1532 APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended()); 1533 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven, 1534 &losesInfo); 1535 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN)); 1536 EXPECT_FALSE(losesInfo); 1537 1538 test = APFloat::getSNaN(APFloat::x87DoubleExtended()); 1539 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven, 1540 &losesInfo); 1541 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN)); 1542 EXPECT_FALSE(losesInfo); 1543 1544 test = APFloat::getQNaN(APFloat::x87DoubleExtended()); 1545 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven, 1546 &losesInfo); 1547 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN)); 1548 EXPECT_FALSE(losesInfo); 1549 } 1550 1551 TEST(APFloatTest, PPCDoubleDouble) { 1552 APFloat test(APFloat::PPCDoubleDouble(), "1.0"); 1553 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]); 1554 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]); 1555 1556 // LDBL_MAX 1557 test = APFloat(APFloat::PPCDoubleDouble(), "1.79769313486231580793728971405301e+308"); 1558 EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]); 1559 EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]); 1560 1561 // LDBL_MIN 1562 test = APFloat(APFloat::PPCDoubleDouble(), "2.00416836000897277799610805135016e-292"); 1563 EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]); 1564 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]); 1565 1566 // PR30869 1567 { 1568 auto Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") + 1569 APFloat(APFloat::PPCDoubleDouble(), "1.0"); 1570 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics()); 1571 1572 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") - 1573 APFloat(APFloat::PPCDoubleDouble(), "1.0"); 1574 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics()); 1575 1576 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") * 1577 APFloat(APFloat::PPCDoubleDouble(), "1.0"); 1578 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics()); 1579 1580 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") / 1581 APFloat(APFloat::PPCDoubleDouble(), "1.0"); 1582 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics()); 1583 1584 int Exp; 1585 Result = frexp(APFloat(APFloat::PPCDoubleDouble(), "1.0"), Exp, 1586 APFloat::rmNearestTiesToEven); 1587 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics()); 1588 1589 Result = scalbn(APFloat(APFloat::PPCDoubleDouble(), "1.0"), 1, 1590 APFloat::rmNearestTiesToEven); 1591 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics()); 1592 } 1593 } 1594 1595 TEST(APFloatTest, isNegative) { 1596 APFloat t(APFloat::IEEEsingle(), "0x1p+0"); 1597 EXPECT_FALSE(t.isNegative()); 1598 t = APFloat(APFloat::IEEEsingle(), "-0x1p+0"); 1599 EXPECT_TRUE(t.isNegative()); 1600 1601 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNegative()); 1602 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), true).isNegative()); 1603 1604 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNegative()); 1605 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), true).isNegative()); 1606 1607 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNegative()); 1608 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), true).isNegative()); 1609 1610 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNegative()); 1611 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isNegative()); 1612 } 1613 1614 TEST(APFloatTest, isNormal) { 1615 APFloat t(APFloat::IEEEsingle(), "0x1p+0"); 1616 EXPECT_TRUE(t.isNormal()); 1617 1618 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNormal()); 1619 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNormal()); 1620 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNormal()); 1621 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNormal()); 1622 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNormal()); 1623 } 1624 1625 TEST(APFloatTest, isFinite) { 1626 APFloat t(APFloat::IEEEsingle(), "0x1p+0"); 1627 EXPECT_TRUE(t.isFinite()); 1628 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFinite()); 1629 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), false).isFinite()); 1630 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFinite()); 1631 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFinite()); 1632 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFinite()); 1633 } 1634 1635 TEST(APFloatTest, isInfinity) { 1636 APFloat t(APFloat::IEEEsingle(), "0x1p+0"); 1637 EXPECT_FALSE(t.isInfinity()); 1638 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), false).isInfinity()); 1639 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isInfinity()); 1640 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isInfinity()); 1641 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isInfinity()); 1642 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isInfinity()); 1643 } 1644 1645 TEST(APFloatTest, isNaN) { 1646 APFloat t(APFloat::IEEEsingle(), "0x1p+0"); 1647 EXPECT_FALSE(t.isNaN()); 1648 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNaN()); 1649 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNaN()); 1650 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNaN()); 1651 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNaN()); 1652 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNaN()); 1653 } 1654 1655 TEST(APFloatTest, isFiniteNonZero) { 1656 // Test positive/negative normal value. 1657 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p+0").isFiniteNonZero()); 1658 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p+0").isFiniteNonZero()); 1659 1660 // Test positive/negative denormal value. 1661 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFiniteNonZero()); 1662 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").isFiniteNonZero()); 1663 1664 // Test +/- Infinity. 1665 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFiniteNonZero()); 1666 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), true).isFiniteNonZero()); 1667 1668 // Test +/- Zero. 1669 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isFiniteNonZero()); 1670 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), true).isFiniteNonZero()); 1671 1672 // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in 1673 // this instance. 1674 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFiniteNonZero()); 1675 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), true).isFiniteNonZero()); 1676 1677 // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in 1678 // this instance. 1679 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFiniteNonZero()); 1680 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isFiniteNonZero()); 1681 } 1682 1683 TEST(APFloatTest, add) { 1684 // Test Special Cases against each other and normal values. 1685 1686 // TODOS/NOTES: 1687 // 1. Since we perform only default exception handling all operations with 1688 // signaling NaNs should have a result that is a quiet NaN. Currently they 1689 // return sNaN. 1690 1691 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false); 1692 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true); 1693 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false); 1694 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true); 1695 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false); 1696 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false); 1697 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0"); 1698 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0"); 1699 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false); 1700 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true); 1701 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false); 1702 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true); 1703 APFloat PSmallestNormalized = 1704 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false); 1705 APFloat MSmallestNormalized = 1706 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true); 1707 1708 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact; 1709 1710 const unsigned NumTests = 169; 1711 struct { 1712 APFloat x; 1713 APFloat y; 1714 const char *result; 1715 int status; 1716 int category; 1717 } SpecialCaseTests[NumTests] = { 1718 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1719 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1720 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 1721 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 1722 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1723 #if 0 1724 // See Note 1. 1725 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1726 #endif 1727 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1728 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1729 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1730 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1731 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1732 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1733 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 1734 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 1735 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1736 { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1737 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1738 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1739 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1740 #if 0 1741 // See Note 1. 1742 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1743 #endif 1744 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1745 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1746 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1747 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1748 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1749 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1750 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1751 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1752 { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1753 { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1754 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1755 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1756 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1757 #if 0 1758 // See Note 1. 1759 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1760 #endif 1761 { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1762 { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1763 { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1764 { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1765 { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1766 { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1767 { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1768 { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1769 { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1770 { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1771 { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1772 { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 1773 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1774 #if 0 1775 // See Note 1. 1776 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1777 #endif 1778 { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1779 { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1780 { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1781 { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1782 { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1783 { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1784 { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1785 { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1786 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 1787 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, 1788 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 1789 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN }, 1790 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1791 #if 0 1792 // See Note 1. 1793 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1794 #endif 1795 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1796 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1797 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1798 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1799 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1800 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1801 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 1802 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 1803 #if 0 1804 // See Note 1. 1805 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1806 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1807 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1808 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1809 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1810 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1811 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1812 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1813 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1814 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1815 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1816 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1817 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1818 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1819 #endif 1820 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1821 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1822 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1823 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1824 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1825 #if 0 1826 // See Note 1. 1827 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1828 #endif 1829 { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal }, 1830 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1831 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1832 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1833 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1834 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1835 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1836 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1837 { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1838 { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1839 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1840 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1841 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1842 #if 0 1843 // See Note 1. 1844 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1845 #endif 1846 { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1847 { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal }, 1848 { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1849 { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1850 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1851 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1852 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1853 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1854 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1855 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1856 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1857 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1858 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1859 #if 0 1860 // See Note 1. 1861 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1862 #endif 1863 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1864 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1865 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 1866 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1867 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1868 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1869 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1870 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1871 { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1872 { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1873 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1874 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1875 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1876 #if 0 1877 // See Note 1. 1878 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1879 #endif 1880 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1881 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1882 { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1883 { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 1884 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1885 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1886 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1887 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1888 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1889 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1890 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1891 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1892 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1893 #if 0 1894 // See Note 1. 1895 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1896 #endif 1897 { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1898 { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1899 { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1900 { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1901 { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal }, 1902 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1903 { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 1904 { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 1905 { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1906 { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1907 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1908 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1909 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1910 #if 0 1911 // See Note 1. 1912 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1913 #endif 1914 { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1915 { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1916 { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1917 { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1918 { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1919 { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal }, 1920 { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 1921 { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 1922 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1923 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1924 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1925 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1926 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1927 #if 0 1928 // See Note 1. 1929 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1930 #endif 1931 { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1932 { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1933 { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1934 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1935 { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 1936 { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 1937 { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal }, 1938 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1939 { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1940 { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1941 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1942 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1943 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1944 #if 0 1945 // See Note 1. 1946 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1947 #endif 1948 { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1949 { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1950 { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1951 { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1952 { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 1953 { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 1954 { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1955 { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal } 1956 }; 1957 1958 for (size_t i = 0; i < NumTests; ++i) { 1959 APFloat x(SpecialCaseTests[i].x); 1960 APFloat y(SpecialCaseTests[i].y); 1961 APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven); 1962 1963 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result); 1964 1965 EXPECT_TRUE(result.bitwiseIsEqual(x)); 1966 EXPECT_TRUE((int)status == SpecialCaseTests[i].status); 1967 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category); 1968 } 1969 } 1970 1971 TEST(APFloatTest, subtract) { 1972 // Test Special Cases against each other and normal values. 1973 1974 // TODOS/NOTES: 1975 // 1. Since we perform only default exception handling all operations with 1976 // signaling NaNs should have a result that is a quiet NaN. Currently they 1977 // return sNaN. 1978 1979 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false); 1980 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true); 1981 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false); 1982 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true); 1983 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false); 1984 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false); 1985 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0"); 1986 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0"); 1987 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false); 1988 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true); 1989 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false); 1990 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true); 1991 APFloat PSmallestNormalized = 1992 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false); 1993 APFloat MSmallestNormalized = 1994 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true); 1995 1996 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact; 1997 1998 const unsigned NumTests = 169; 1999 struct { 2000 APFloat x; 2001 APFloat y; 2002 const char *result; 2003 int status; 2004 int category; 2005 } SpecialCaseTests[NumTests] = { 2006 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2007 { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2008 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 2009 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 2010 { PInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2011 #if 0 2012 // See Note 1. 2013 { PInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2014 #endif 2015 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2016 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2017 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2018 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2019 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2020 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2021 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2022 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2023 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2024 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2025 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2026 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2027 { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2028 #if 0 2029 // See Note 1. 2030 { MInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2031 #endif 2032 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2033 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2034 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2035 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2036 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2037 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2038 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2039 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2040 { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2041 { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2042 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2043 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2044 { PZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2045 #if 0 2046 // See Note 1. 2047 { PZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2048 #endif 2049 { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2050 { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2051 { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2052 { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2053 { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2054 { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2055 { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2056 { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2057 { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2058 { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2059 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2060 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2061 { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2062 #if 0 2063 // See Note 1. 2064 { MZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2065 #endif 2066 { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2067 { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2068 { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2069 { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2070 { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2071 { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2072 { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2073 { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2074 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2075 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2076 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2077 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2078 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2079 #if 0 2080 // See Note 1. 2081 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2082 #endif 2083 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2084 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2085 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2086 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2087 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2088 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2089 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2090 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2091 #if 0 2092 // See Note 1. 2093 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2094 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2095 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2096 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2097 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2098 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2099 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2100 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2101 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2102 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2103 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2104 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2105 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2106 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2107 #endif 2108 { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2109 { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2110 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2111 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2112 { PNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2113 #if 0 2114 // See Note 1. 2115 { PNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2116 #endif 2117 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2118 { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal }, 2119 { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2120 { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2121 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2122 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2123 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2124 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2125 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2126 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2127 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2128 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2129 { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2130 #if 0 2131 // See Note 1. 2132 { MNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2133 #endif 2134 { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal }, 2135 { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2136 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2137 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2138 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2139 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2140 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2141 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2142 { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2143 { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2144 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2145 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2146 { PLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2147 #if 0 2148 // See Note 1. 2149 { PLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2150 #endif 2151 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2152 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2153 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2154 { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2155 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2156 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2157 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2158 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2159 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2160 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2161 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2162 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2163 { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2164 #if 0 2165 // See Note 1. 2166 { MLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2167 #endif 2168 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2169 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2170 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2171 { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2172 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2173 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2174 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2175 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2176 { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2177 { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2178 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2179 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2180 { PSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2181 #if 0 2182 // See Note 1. 2183 { PSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2184 #endif 2185 { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2186 { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2187 { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2188 { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2189 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2190 { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal }, 2191 { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2192 { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2193 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2194 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2195 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2196 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2197 { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2198 #if 0 2199 // See Note 1. 2200 { MSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2201 #endif 2202 { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2203 { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2204 { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2205 { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2206 { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal }, 2207 { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2208 { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2209 { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2210 { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2211 { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2212 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2213 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2214 { PSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2215 #if 0 2216 // See Note 1. 2217 { PSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2218 #endif 2219 { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2220 { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2221 { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2222 { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2223 { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2224 { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2225 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2226 { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal }, 2227 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2228 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2229 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2230 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2231 { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2232 #if 0 2233 // See Note 1. 2234 { MSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2235 #endif 2236 { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2237 { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2238 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2239 { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2240 { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2241 { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2242 { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }, 2243 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero } 2244 }; 2245 2246 for (size_t i = 0; i < NumTests; ++i) { 2247 APFloat x(SpecialCaseTests[i].x); 2248 APFloat y(SpecialCaseTests[i].y); 2249 APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven); 2250 2251 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result); 2252 2253 EXPECT_TRUE(result.bitwiseIsEqual(x)); 2254 EXPECT_TRUE((int)status == SpecialCaseTests[i].status); 2255 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category); 2256 } 2257 } 2258 2259 TEST(APFloatTest, multiply) { 2260 // Test Special Cases against each other and normal values. 2261 2262 // TODOS/NOTES: 2263 // 1. Since we perform only default exception handling all operations with 2264 // signaling NaNs should have a result that is a quiet NaN. Currently they 2265 // return sNaN. 2266 2267 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false); 2268 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true); 2269 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false); 2270 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true); 2271 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false); 2272 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false); 2273 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0"); 2274 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0"); 2275 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false); 2276 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true); 2277 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false); 2278 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true); 2279 APFloat PSmallestNormalized = 2280 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false); 2281 APFloat MSmallestNormalized = 2282 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true); 2283 2284 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact; 2285 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact; 2286 2287 const unsigned NumTests = 169; 2288 struct { 2289 APFloat x; 2290 APFloat y; 2291 const char *result; 2292 int status; 2293 int category; 2294 } SpecialCaseTests[NumTests] = { 2295 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2296 { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2297 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2298 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2299 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2300 #if 0 2301 // See Note 1. 2302 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2303 #endif 2304 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2305 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2306 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2307 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2308 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2309 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2310 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2311 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2312 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2313 { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2314 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2315 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2316 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2317 #if 0 2318 // See Note 1. 2319 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2320 #endif 2321 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2322 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2323 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2324 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2325 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2326 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2327 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2328 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2329 { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2330 { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2331 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2332 { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2333 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2334 #if 0 2335 // See Note 1. 2336 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2337 #endif 2338 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2339 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2340 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2341 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2342 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2343 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2344 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2345 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2346 { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2347 { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2348 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2349 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2350 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2351 #if 0 2352 // See Note 1. 2353 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2354 #endif 2355 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2356 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2357 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2358 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2359 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2360 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2361 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2362 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2363 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2364 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2365 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2366 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2367 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2368 #if 0 2369 // See Note 1. 2370 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2371 #endif 2372 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2373 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2374 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2375 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2376 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2377 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2378 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2379 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2380 #if 0 2381 // See Note 1. 2382 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2383 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2384 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2385 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2386 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2387 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2388 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2389 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2390 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2391 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2392 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2393 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2394 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2395 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2396 #endif 2397 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2398 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2399 { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2400 { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2401 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2402 #if 0 2403 // See Note 1. 2404 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2405 #endif 2406 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2407 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2408 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2409 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2410 { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2411 { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2412 { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2413 { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2414 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2415 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2416 { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2417 { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2418 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2419 #if 0 2420 // See Note 1. 2421 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2422 #endif 2423 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2424 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2425 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2426 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2427 { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2428 { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2429 { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2430 { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2431 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2432 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2433 { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2434 { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2435 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2436 #if 0 2437 // See Note 1. 2438 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2439 #endif 2440 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2441 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2442 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2443 { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2444 { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2445 { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2446 { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2447 { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2448 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2449 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2450 { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2451 { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2452 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2453 #if 0 2454 // See Note 1. 2455 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2456 #endif 2457 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2458 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2459 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2460 { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2461 { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2462 { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2463 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2464 { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2465 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2466 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2467 { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2468 { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2469 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2470 #if 0 2471 // See Note 1. 2472 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2473 #endif 2474 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2475 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2476 { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2477 { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2478 { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2479 { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2480 { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2481 { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2482 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2483 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2484 { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2485 { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2486 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2487 #if 0 2488 // See Note 1. 2489 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2490 #endif 2491 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2492 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2493 { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2494 { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2495 { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2496 { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2497 { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2498 { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2499 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2500 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2501 { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2502 { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2503 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2504 #if 0 2505 // See Note 1. 2506 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2507 #endif 2508 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2509 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2510 { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2511 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2512 { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2513 { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2514 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2515 { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2516 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2517 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2518 { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2519 { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2520 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2521 #if 0 2522 // See Note 1. 2523 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2524 #endif 2525 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2526 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2527 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2528 { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2529 { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2530 { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2531 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2532 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero } 2533 }; 2534 2535 for (size_t i = 0; i < NumTests; ++i) { 2536 APFloat x(SpecialCaseTests[i].x); 2537 APFloat y(SpecialCaseTests[i].y); 2538 APFloat::opStatus status = x.multiply(y, APFloat::rmNearestTiesToEven); 2539 2540 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result); 2541 2542 EXPECT_TRUE(result.bitwiseIsEqual(x)); 2543 EXPECT_TRUE((int)status == SpecialCaseTests[i].status); 2544 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category); 2545 } 2546 } 2547 2548 TEST(APFloatTest, divide) { 2549 // Test Special Cases against each other and normal values. 2550 2551 // TODOS/NOTES: 2552 // 1. Since we perform only default exception handling all operations with 2553 // signaling NaNs should have a result that is a quiet NaN. Currently they 2554 // return sNaN. 2555 2556 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false); 2557 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true); 2558 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false); 2559 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true); 2560 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false); 2561 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false); 2562 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0"); 2563 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0"); 2564 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false); 2565 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true); 2566 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false); 2567 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true); 2568 APFloat PSmallestNormalized = 2569 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false); 2570 APFloat MSmallestNormalized = 2571 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true); 2572 2573 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact; 2574 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact; 2575 2576 const unsigned NumTests = 169; 2577 struct { 2578 APFloat x; 2579 APFloat y; 2580 const char *result; 2581 int status; 2582 int category; 2583 } SpecialCaseTests[NumTests] = { 2584 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2585 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2586 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 2587 { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2588 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2589 #if 0 2590 // See Note 1. 2591 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2592 #endif 2593 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2594 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2595 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2596 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2597 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2598 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2599 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2600 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2601 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2602 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2603 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2604 { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 2605 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2606 #if 0 2607 // See Note 1. 2608 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2609 #endif 2610 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2611 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2612 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2613 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2614 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2615 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2616 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2617 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2618 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2619 { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2620 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2621 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2622 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2623 #if 0 2624 // See Note 1. 2625 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2626 #endif 2627 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2628 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2629 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2630 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2631 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2632 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2633 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2634 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2635 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2636 { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2637 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2638 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2639 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2640 #if 0 2641 // See Note 1. 2642 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2643 #endif 2644 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2645 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2646 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2647 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2648 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2649 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2650 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2651 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2652 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2653 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2654 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2655 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2656 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2657 #if 0 2658 // See Note 1. 2659 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2660 #endif 2661 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2662 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2663 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2664 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2665 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2666 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2667 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2668 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2669 #if 0 2670 // See Note 1. 2671 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2672 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2673 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2674 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2675 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2676 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2677 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2678 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2679 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2680 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2681 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2682 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2683 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2684 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2685 #endif 2686 { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2687 { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2688 { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2689 { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2690 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2691 #if 0 2692 // See Note 1. 2693 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2694 #endif 2695 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2696 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2697 { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal }, 2698 { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal }, 2699 { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2700 { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2701 { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal }, 2702 { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal }, 2703 { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2704 { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2705 { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2706 { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2707 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2708 #if 0 2709 // See Note 1. 2710 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2711 #endif 2712 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2713 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2714 { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal }, 2715 { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal }, 2716 { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2717 { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2718 { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal }, 2719 { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal }, 2720 { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2721 { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2722 { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2723 { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2724 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2725 #if 0 2726 // See Note 1. 2727 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2728 #endif 2729 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2730 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2731 { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2732 { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2733 { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2734 { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2735 { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity }, 2736 { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity }, 2737 { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2738 { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2739 { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2740 { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2741 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2742 #if 0 2743 // See Note 1. 2744 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2745 #endif 2746 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2747 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2748 { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2749 { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2750 { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2751 { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2752 { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity }, 2753 { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity }, 2754 { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2755 { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2756 { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2757 { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2758 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2759 #if 0 2760 // See Note 1. 2761 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2762 #endif 2763 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2764 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2765 { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2766 { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2767 { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2768 { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2769 { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal }, 2770 { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal }, 2771 { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2772 { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2773 { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2774 { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2775 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2776 #if 0 2777 // See Note 1. 2778 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2779 #endif 2780 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2781 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2782 { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2783 { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2784 { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2785 { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2786 { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal }, 2787 { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal }, 2788 { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2789 { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2790 { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2791 { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2792 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2793 #if 0 2794 // See Note 1. 2795 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2796 #endif 2797 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2798 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2799 { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2800 { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2801 { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal }, 2802 { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal }, 2803 { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2804 { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2805 { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2806 { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2807 { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2808 { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2809 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2810 #if 0 2811 // See Note 1. 2812 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2813 #endif 2814 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2815 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2816 { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2817 { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2818 { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal }, 2819 { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal }, 2820 { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2821 { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2822 }; 2823 2824 for (size_t i = 0; i < NumTests; ++i) { 2825 APFloat x(SpecialCaseTests[i].x); 2826 APFloat y(SpecialCaseTests[i].y); 2827 APFloat::opStatus status = x.divide(y, APFloat::rmNearestTiesToEven); 2828 2829 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result); 2830 2831 EXPECT_TRUE(result.bitwiseIsEqual(x)); 2832 EXPECT_TRUE((int)status == SpecialCaseTests[i].status); 2833 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category); 2834 } 2835 } 2836 2837 TEST(APFloatTest, operatorOverloads) { 2838 // This is mostly testing that these operator overloads compile. 2839 APFloat One = APFloat(APFloat::IEEEsingle(), "0x1p+0"); 2840 APFloat Two = APFloat(APFloat::IEEEsingle(), "0x2p+0"); 2841 EXPECT_TRUE(Two.bitwiseIsEqual(One + One)); 2842 EXPECT_TRUE(One.bitwiseIsEqual(Two - One)); 2843 EXPECT_TRUE(Two.bitwiseIsEqual(One * Two)); 2844 EXPECT_TRUE(One.bitwiseIsEqual(Two / Two)); 2845 } 2846 2847 TEST(APFloatTest, abs) { 2848 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false); 2849 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true); 2850 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false); 2851 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true); 2852 APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle(), false); 2853 APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true); 2854 APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false); 2855 APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), true); 2856 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0"); 2857 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0"); 2858 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false); 2859 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true); 2860 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false); 2861 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true); 2862 APFloat PSmallestNormalized = 2863 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false); 2864 APFloat MSmallestNormalized = 2865 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true); 2866 2867 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(PInf))); 2868 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(MInf))); 2869 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(PZero))); 2870 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(MZero))); 2871 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(PQNaN))); 2872 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(MQNaN))); 2873 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(PSNaN))); 2874 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(MSNaN))); 2875 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(PNormalValue))); 2876 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(MNormalValue))); 2877 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(PLargestValue))); 2878 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(MLargestValue))); 2879 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(PSmallestValue))); 2880 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(MSmallestValue))); 2881 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(PSmallestNormalized))); 2882 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized))); 2883 } 2884 2885 TEST(APFloatTest, neg) { 2886 APFloat One = APFloat(APFloat::IEEEsingle(), "1.0"); 2887 APFloat NegOne = APFloat(APFloat::IEEEsingle(), "-1.0"); 2888 APFloat Zero = APFloat::getZero(APFloat::IEEEsingle(), false); 2889 APFloat NegZero = APFloat::getZero(APFloat::IEEEsingle(), true); 2890 APFloat Inf = APFloat::getInf(APFloat::IEEEsingle(), false); 2891 APFloat NegInf = APFloat::getInf(APFloat::IEEEsingle(), true); 2892 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false); 2893 APFloat NegQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true); 2894 2895 EXPECT_TRUE(NegOne.bitwiseIsEqual(neg(One))); 2896 EXPECT_TRUE(One.bitwiseIsEqual(neg(NegOne))); 2897 EXPECT_TRUE(NegZero.bitwiseIsEqual(neg(Zero))); 2898 EXPECT_TRUE(Zero.bitwiseIsEqual(neg(NegZero))); 2899 EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf))); 2900 EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf))); 2901 EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf))); 2902 EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf))); 2903 EXPECT_TRUE(NegQNaN.bitwiseIsEqual(neg(QNaN))); 2904 EXPECT_TRUE(QNaN.bitwiseIsEqual(neg(NegQNaN))); 2905 } 2906 2907 TEST(APFloatTest, ilogb) { 2908 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), false))); 2909 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), true))); 2910 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1024"))); 2911 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023"))); 2912 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023"))); 2913 EXPECT_EQ(-51, ilogb(APFloat(APFloat::IEEEdouble(), "0x1p-51"))); 2914 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1023"))); 2915 EXPECT_EQ(-2, ilogb(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1"))); 2916 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1023"))); 2917 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), false))); 2918 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), true))); 2919 2920 2921 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+0"))); 2922 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "-0x1p+0"))); 2923 EXPECT_EQ(42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+42"))); 2924 EXPECT_EQ(-42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p-42"))); 2925 2926 EXPECT_EQ(APFloat::IEK_Inf, 2927 ilogb(APFloat::getInf(APFloat::IEEEsingle(), false))); 2928 EXPECT_EQ(APFloat::IEK_Inf, 2929 ilogb(APFloat::getInf(APFloat::IEEEsingle(), true))); 2930 EXPECT_EQ(APFloat::IEK_Zero, 2931 ilogb(APFloat::getZero(APFloat::IEEEsingle(), false))); 2932 EXPECT_EQ(APFloat::IEK_Zero, 2933 ilogb(APFloat::getZero(APFloat::IEEEsingle(), true))); 2934 EXPECT_EQ(APFloat::IEK_NaN, 2935 ilogb(APFloat::getNaN(APFloat::IEEEsingle(), false))); 2936 EXPECT_EQ(APFloat::IEK_NaN, 2937 ilogb(APFloat::getSNaN(APFloat::IEEEsingle(), false))); 2938 2939 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), false))); 2940 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), true))); 2941 2942 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), false))); 2943 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), true))); 2944 EXPECT_EQ(-126, 2945 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false))); 2946 EXPECT_EQ(-126, 2947 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true))); 2948 } 2949 2950 TEST(APFloatTest, scalbn) { 2951 2952 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven; 2953 EXPECT_TRUE( 2954 APFloat(APFloat::IEEEsingle(), "0x1p+0") 2955 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 0, RM))); 2956 EXPECT_TRUE( 2957 APFloat(APFloat::IEEEsingle(), "0x1p+42") 2958 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 42, RM))); 2959 EXPECT_TRUE( 2960 APFloat(APFloat::IEEEsingle(), "0x1p-42") 2961 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), -42, RM))); 2962 2963 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false); 2964 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true); 2965 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false); 2966 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true); 2967 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle(), false); 2968 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle(), true); 2969 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false); 2970 2971 EXPECT_TRUE(PInf.bitwiseIsEqual(scalbn(PInf, 0, RM))); 2972 EXPECT_TRUE(MInf.bitwiseIsEqual(scalbn(MInf, 0, RM))); 2973 EXPECT_TRUE(PZero.bitwiseIsEqual(scalbn(PZero, 0, RM))); 2974 EXPECT_TRUE(MZero.bitwiseIsEqual(scalbn(MZero, 0, RM))); 2975 EXPECT_TRUE(QPNaN.bitwiseIsEqual(scalbn(QPNaN, 0, RM))); 2976 EXPECT_TRUE(QMNaN.bitwiseIsEqual(scalbn(QMNaN, 0, RM))); 2977 EXPECT_FALSE(scalbn(SNaN, 0, RM).isSignaling()); 2978 2979 APFloat ScalbnSNaN = scalbn(SNaN, 1, RM); 2980 EXPECT_TRUE(ScalbnSNaN.isNaN() && !ScalbnSNaN.isSignaling()); 2981 2982 // Make sure highest bit of payload is preserved. 2983 const APInt Payload(64, (UINT64_C(1) << 50) | 2984 (UINT64_C(1) << 49) | 2985 (UINT64_C(1234) << 32) | 2986 1); 2987 2988 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false, 2989 &Payload); 2990 APFloat QuietPayload = scalbn(SNaNWithPayload, 1, RM); 2991 EXPECT_TRUE(QuietPayload.isNaN() && !QuietPayload.isSignaling()); 2992 EXPECT_EQ(Payload, QuietPayload.bitcastToAPInt().getLoBits(51)); 2993 2994 EXPECT_TRUE(PInf.bitwiseIsEqual( 2995 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 128, RM))); 2996 EXPECT_TRUE(MInf.bitwiseIsEqual( 2997 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p+0"), 128, RM))); 2998 EXPECT_TRUE(PInf.bitwiseIsEqual( 2999 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+127"), 1, RM))); 3000 EXPECT_TRUE(PZero.bitwiseIsEqual( 3001 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-127"), -127, RM))); 3002 EXPECT_TRUE(MZero.bitwiseIsEqual( 3003 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -127, RM))); 3004 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").bitwiseIsEqual( 3005 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -22, RM))); 3006 EXPECT_TRUE(PZero.bitwiseIsEqual( 3007 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-126"), -24, RM))); 3008 3009 3010 APFloat SmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), false); 3011 APFloat NegSmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), true); 3012 3013 APFloat LargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), false); 3014 APFloat NegLargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), true); 3015 3016 APFloat SmallestNormalizedF64 3017 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false); 3018 APFloat NegSmallestNormalizedF64 3019 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true); 3020 3021 APFloat LargestDenormalF64(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023"); 3022 APFloat NegLargestDenormalF64(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023"); 3023 3024 3025 EXPECT_TRUE(SmallestF64.bitwiseIsEqual( 3026 scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-1074"), 0, RM))); 3027 EXPECT_TRUE(NegSmallestF64.bitwiseIsEqual( 3028 scalbn(APFloat(APFloat::IEEEdouble(), "-0x1p-1074"), 0, RM))); 3029 3030 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023") 3031 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM))); 3032 3033 EXPECT_TRUE(scalbn(SmallestF64, -2097, RM).isPosZero()); 3034 EXPECT_TRUE(scalbn(SmallestF64, -2098, RM).isPosZero()); 3035 EXPECT_TRUE(scalbn(SmallestF64, -2099, RM).isPosZero()); 3036 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1022") 3037 .bitwiseIsEqual(scalbn(SmallestF64, 2096, RM))); 3038 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023") 3039 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM))); 3040 EXPECT_TRUE(scalbn(SmallestF64, 2098, RM).isInfinity()); 3041 EXPECT_TRUE(scalbn(SmallestF64, 2099, RM).isInfinity()); 3042 3043 // Test for integer overflows when adding to exponent. 3044 EXPECT_TRUE(scalbn(SmallestF64, -INT_MAX, RM).isPosZero()); 3045 EXPECT_TRUE(scalbn(LargestF64, INT_MAX, RM).isInfinity()); 3046 3047 EXPECT_TRUE(LargestDenormalF64 3048 .bitwiseIsEqual(scalbn(LargestDenormalF64, 0, RM))); 3049 EXPECT_TRUE(NegLargestDenormalF64 3050 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 0, RM))); 3051 3052 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1022") 3053 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1, RM))); 3054 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1021") 3055 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 2, RM))); 3056 3057 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1") 3058 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1024, RM))); 3059 EXPECT_TRUE(scalbn(LargestDenormalF64, -1023, RM).isPosZero()); 3060 EXPECT_TRUE(scalbn(LargestDenormalF64, -1024, RM).isPosZero()); 3061 EXPECT_TRUE(scalbn(LargestDenormalF64, -2048, RM).isPosZero()); 3062 EXPECT_TRUE(scalbn(LargestDenormalF64, 2047, RM).isInfinity()); 3063 EXPECT_TRUE(scalbn(LargestDenormalF64, 2098, RM).isInfinity()); 3064 EXPECT_TRUE(scalbn(LargestDenormalF64, 2099, RM).isInfinity()); 3065 3066 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-2") 3067 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1021, RM))); 3068 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1") 3069 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1022, RM))); 3070 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+0") 3071 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1023, RM))); 3072 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1023") 3073 .bitwiseIsEqual(scalbn(LargestDenormalF64, 2046, RM))); 3074 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+974") 3075 .bitwiseIsEqual(scalbn(SmallestF64, 2048, RM))); 3076 3077 APFloat RandomDenormalF64(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51"); 3078 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-972") 3079 .bitwiseIsEqual(scalbn(RandomDenormalF64, -1023, RM))); 3080 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1") 3081 .bitwiseIsEqual(scalbn(RandomDenormalF64, -52, RM))); 3082 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-2") 3083 .bitwiseIsEqual(scalbn(RandomDenormalF64, -53, RM))); 3084 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+0") 3085 .bitwiseIsEqual(scalbn(RandomDenormalF64, -51, RM))); 3086 3087 EXPECT_TRUE(scalbn(RandomDenormalF64, -2097, RM).isPosZero()); 3088 EXPECT_TRUE(scalbn(RandomDenormalF64, -2090, RM).isPosZero()); 3089 3090 3091 EXPECT_TRUE( 3092 APFloat(APFloat::IEEEdouble(), "-0x1p-1073") 3093 .bitwiseIsEqual(scalbn(NegLargestF64, -2097, RM))); 3094 3095 EXPECT_TRUE( 3096 APFloat(APFloat::IEEEdouble(), "-0x1p-1024") 3097 .bitwiseIsEqual(scalbn(NegLargestF64, -2048, RM))); 3098 3099 EXPECT_TRUE( 3100 APFloat(APFloat::IEEEdouble(), "0x1p-1073") 3101 .bitwiseIsEqual(scalbn(LargestF64, -2097, RM))); 3102 3103 EXPECT_TRUE( 3104 APFloat(APFloat::IEEEdouble(), "0x1p-1074") 3105 .bitwiseIsEqual(scalbn(LargestF64, -2098, RM))); 3106 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1074") 3107 .bitwiseIsEqual(scalbn(NegLargestF64, -2098, RM))); 3108 EXPECT_TRUE(scalbn(NegLargestF64, -2099, RM).isNegZero()); 3109 EXPECT_TRUE(scalbn(LargestF64, 1, RM).isInfinity()); 3110 3111 3112 EXPECT_TRUE( 3113 APFloat(APFloat::IEEEdouble(), "0x1p+0") 3114 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p+52"), -52, RM))); 3115 3116 EXPECT_TRUE( 3117 APFloat(APFloat::IEEEdouble(), "0x1p-103") 3118 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-51"), -52, RM))); 3119 } 3120 3121 TEST(APFloatTest, frexp) { 3122 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven; 3123 3124 APFloat PZero = APFloat::getZero(APFloat::IEEEdouble(), false); 3125 APFloat MZero = APFloat::getZero(APFloat::IEEEdouble(), true); 3126 APFloat One(1.0); 3127 APFloat MOne(-1.0); 3128 APFloat Two(2.0); 3129 APFloat MTwo(-2.0); 3130 3131 APFloat LargestDenormal(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023"); 3132 APFloat NegLargestDenormal(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023"); 3133 3134 APFloat Smallest = APFloat::getSmallest(APFloat::IEEEdouble(), false); 3135 APFloat NegSmallest = APFloat::getSmallest(APFloat::IEEEdouble(), true); 3136 3137 APFloat Largest = APFloat::getLargest(APFloat::IEEEdouble(), false); 3138 APFloat NegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true); 3139 3140 APFloat PInf = APFloat::getInf(APFloat::IEEEdouble(), false); 3141 APFloat MInf = APFloat::getInf(APFloat::IEEEdouble(), true); 3142 3143 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEdouble(), false); 3144 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEdouble(), true); 3145 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEdouble(), false); 3146 3147 // Make sure highest bit of payload is preserved. 3148 const APInt Payload(64, (UINT64_C(1) << 50) | 3149 (UINT64_C(1) << 49) | 3150 (UINT64_C(1234) << 32) | 3151 1); 3152 3153 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false, 3154 &Payload); 3155 3156 APFloat SmallestNormalized 3157 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false); 3158 APFloat NegSmallestNormalized 3159 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true); 3160 3161 int Exp; 3162 APFloat Frac(APFloat::IEEEdouble()); 3163 3164 3165 Frac = frexp(PZero, Exp, RM); 3166 EXPECT_EQ(0, Exp); 3167 EXPECT_TRUE(Frac.isPosZero()); 3168 3169 Frac = frexp(MZero, Exp, RM); 3170 EXPECT_EQ(0, Exp); 3171 EXPECT_TRUE(Frac.isNegZero()); 3172 3173 3174 Frac = frexp(One, Exp, RM); 3175 EXPECT_EQ(1, Exp); 3176 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac)); 3177 3178 Frac = frexp(MOne, Exp, RM); 3179 EXPECT_EQ(1, Exp); 3180 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac)); 3181 3182 Frac = frexp(LargestDenormal, Exp, RM); 3183 EXPECT_EQ(-1022, Exp); 3184 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1").bitwiseIsEqual(Frac)); 3185 3186 Frac = frexp(NegLargestDenormal, Exp, RM); 3187 EXPECT_EQ(-1022, Exp); 3188 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1").bitwiseIsEqual(Frac)); 3189 3190 3191 Frac = frexp(Smallest, Exp, RM); 3192 EXPECT_EQ(-1073, Exp); 3193 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac)); 3194 3195 Frac = frexp(NegSmallest, Exp, RM); 3196 EXPECT_EQ(-1073, Exp); 3197 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac)); 3198 3199 3200 Frac = frexp(Largest, Exp, RM); 3201 EXPECT_EQ(1024, Exp); 3202 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffffffffffffp-1").bitwiseIsEqual(Frac)); 3203 3204 Frac = frexp(NegLargest, Exp, RM); 3205 EXPECT_EQ(1024, Exp); 3206 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.fffffffffffffp-1").bitwiseIsEqual(Frac)); 3207 3208 3209 Frac = frexp(PInf, Exp, RM); 3210 EXPECT_EQ(INT_MAX, Exp); 3211 EXPECT_TRUE(Frac.isInfinity() && !Frac.isNegative()); 3212 3213 Frac = frexp(MInf, Exp, RM); 3214 EXPECT_EQ(INT_MAX, Exp); 3215 EXPECT_TRUE(Frac.isInfinity() && Frac.isNegative()); 3216 3217 Frac = frexp(QPNaN, Exp, RM); 3218 EXPECT_EQ(INT_MIN, Exp); 3219 EXPECT_TRUE(Frac.isNaN()); 3220 3221 Frac = frexp(QMNaN, Exp, RM); 3222 EXPECT_EQ(INT_MIN, Exp); 3223 EXPECT_TRUE(Frac.isNaN()); 3224 3225 Frac = frexp(SNaN, Exp, RM); 3226 EXPECT_EQ(INT_MIN, Exp); 3227 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling()); 3228 3229 Frac = frexp(SNaNWithPayload, Exp, RM); 3230 EXPECT_EQ(INT_MIN, Exp); 3231 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling()); 3232 EXPECT_EQ(Payload, Frac.bitcastToAPInt().getLoBits(51)); 3233 3234 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1"), Exp, RM); 3235 EXPECT_EQ(-1, Exp); 3236 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1").bitwiseIsEqual(Frac)); 3237 3238 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1p-51"), Exp, RM); 3239 EXPECT_EQ(-50, Exp); 3240 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac)); 3241 3242 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51"), Exp, RM); 3243 EXPECT_EQ(52, Exp); 3244 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1").bitwiseIsEqual(Frac)); 3245 } 3246 3247 TEST(APFloatTest, mod) { 3248 { 3249 APFloat f1(APFloat::IEEEdouble(), "1.5"); 3250 APFloat f2(APFloat::IEEEdouble(), "1.0"); 3251 APFloat expected(APFloat::IEEEdouble(), "0.5"); 3252 EXPECT_EQ(f1.mod(f2), APFloat::opOK); 3253 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 3254 } 3255 { 3256 APFloat f1(APFloat::IEEEdouble(), "0.5"); 3257 APFloat f2(APFloat::IEEEdouble(), "1.0"); 3258 APFloat expected(APFloat::IEEEdouble(), "0.5"); 3259 EXPECT_EQ(f1.mod(f2), APFloat::opOK); 3260 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 3261 } 3262 { 3263 APFloat f1(APFloat::IEEEdouble(), "0x1.3333333333333p-2"); // 0.3 3264 APFloat f2(APFloat::IEEEdouble(), "0x1.47ae147ae147bp-7"); // 0.01 3265 APFloat expected(APFloat::IEEEdouble(), 3266 "0x1.47ae147ae1471p-7"); // 0.009999999999999983 3267 EXPECT_EQ(f1.mod(f2), APFloat::opOK); 3268 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 3269 } 3270 { 3271 APFloat f1(APFloat::IEEEdouble(), "0x1p64"); // 1.8446744073709552e19 3272 APFloat f2(APFloat::IEEEdouble(), "1.5"); 3273 APFloat expected(APFloat::IEEEdouble(), "1.0"); 3274 EXPECT_EQ(f1.mod(f2), APFloat::opOK); 3275 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 3276 } 3277 { 3278 APFloat f1(APFloat::IEEEdouble(), "0x1p1000"); 3279 APFloat f2(APFloat::IEEEdouble(), "0x1p-1000"); 3280 APFloat expected(APFloat::IEEEdouble(), "0.0"); 3281 EXPECT_EQ(f1.mod(f2), APFloat::opOK); 3282 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 3283 } 3284 { 3285 APFloat f1(APFloat::IEEEdouble(), "0.0"); 3286 APFloat f2(APFloat::IEEEdouble(), "1.0"); 3287 APFloat expected(APFloat::IEEEdouble(), "0.0"); 3288 EXPECT_EQ(f1.mod(f2), APFloat::opOK); 3289 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 3290 } 3291 { 3292 APFloat f1(APFloat::IEEEdouble(), "1.0"); 3293 APFloat f2(APFloat::IEEEdouble(), "0.0"); 3294 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp); 3295 EXPECT_TRUE(f1.isNaN()); 3296 } 3297 { 3298 APFloat f1(APFloat::IEEEdouble(), "0.0"); 3299 APFloat f2(APFloat::IEEEdouble(), "0.0"); 3300 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp); 3301 EXPECT_TRUE(f1.isNaN()); 3302 } 3303 { 3304 APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false); 3305 APFloat f2(APFloat::IEEEdouble(), "1.0"); 3306 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp); 3307 EXPECT_TRUE(f1.isNaN()); 3308 } 3309 { 3310 APFloat f1(APFloat::IEEEdouble(), "-4.0"); 3311 APFloat f2(APFloat::IEEEdouble(), "-2.0"); 3312 APFloat expected(APFloat::IEEEdouble(), "-0.0"); 3313 EXPECT_EQ(f1.mod(f2), APFloat::opOK); 3314 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 3315 } 3316 { 3317 APFloat f1(APFloat::IEEEdouble(), "-4.0"); 3318 APFloat f2(APFloat::IEEEdouble(), "2.0"); 3319 APFloat expected(APFloat::IEEEdouble(), "-0.0"); 3320 EXPECT_EQ(f1.mod(f2), APFloat::opOK); 3321 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 3322 } 3323 } 3324 3325 TEST(APFloatTest, PPCDoubleDoubleAddSpecial) { 3326 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, 3327 APFloat::fltCategory, APFloat::roundingMode>; 3328 DataType Data[] = { 3329 // (1 + 0) + (-1 + 0) = fcZero 3330 std::make_tuple(0x3ff0000000000000ull, 0, 0xbff0000000000000ull, 0, 3331 APFloat::fcZero, APFloat::rmNearestTiesToEven), 3332 // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity 3333 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 3334 0x7948000000000000ull, 0ull, APFloat::fcInfinity, 3335 APFloat::rmNearestTiesToEven), 3336 // TODO: change the 4th 0x75effffffffffffe to 0x75efffffffffffff when 3337 // semPPCDoubleDoubleLegacy is gone. 3338 // LDBL_MAX + (1.011111... >> (1023 - 106) + (1.1111111...0 >> (1023 - 3339 // 160))) = fcNormal 3340 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 3341 0x7947ffffffffffffull, 0x75effffffffffffeull, 3342 APFloat::fcNormal, APFloat::rmNearestTiesToEven), 3343 // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity 3344 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 3345 0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 3346 APFloat::fcInfinity, APFloat::rmNearestTiesToEven), 3347 // NaN + (1 + 0) = fcNaN 3348 std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0, 3349 APFloat::fcNaN, APFloat::rmNearestTiesToEven), 3350 }; 3351 3352 for (auto Tp : Data) { 3353 uint64_t Op1[2], Op2[2]; 3354 APFloat::fltCategory Expected; 3355 APFloat::roundingMode RM; 3356 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp; 3357 3358 { 3359 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 3360 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 3361 A1.add(A2, RM); 3362 3363 EXPECT_EQ(Expected, A1.getCategory()) 3364 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], 3365 Op2[0], Op2[1]) 3366 .str(); 3367 } 3368 { 3369 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 3370 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 3371 A2.add(A1, RM); 3372 3373 EXPECT_EQ(Expected, A2.getCategory()) 3374 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1], 3375 Op1[0], Op1[1]) 3376 .str(); 3377 } 3378 } 3379 } 3380 3381 TEST(APFloatTest, PPCDoubleDoubleAdd) { 3382 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, 3383 uint64_t, APFloat::roundingMode>; 3384 DataType Data[] = { 3385 // (1 + 0) + (1e-105 + 0) = (1 + 1e-105) 3386 std::make_tuple(0x3ff0000000000000ull, 0, 0x3960000000000000ull, 0, 3387 0x3ff0000000000000ull, 0x3960000000000000ull, 3388 APFloat::rmNearestTiesToEven), 3389 // (1 + 0) + (1e-106 + 0) = (1 + 1e-106) 3390 std::make_tuple(0x3ff0000000000000ull, 0, 0x3950000000000000ull, 0, 3391 0x3ff0000000000000ull, 0x3950000000000000ull, 3392 APFloat::rmNearestTiesToEven), 3393 // (1 + 1e-106) + (1e-106 + 0) = (1 + 1e-105) 3394 std::make_tuple(0x3ff0000000000000ull, 0x3950000000000000ull, 3395 0x3950000000000000ull, 0, 0x3ff0000000000000ull, 3396 0x3960000000000000ull, APFloat::rmNearestTiesToEven), 3397 // (1 + 0) + (epsilon + 0) = (1 + epsilon) 3398 std::make_tuple(0x3ff0000000000000ull, 0, 0x0000000000000001ull, 0, 3399 0x3ff0000000000000ull, 0x0000000000000001ull, 3400 APFloat::rmNearestTiesToEven), 3401 // TODO: change 0xf950000000000000 to 0xf940000000000000, when 3402 // semPPCDoubleDoubleLegacy is gone. 3403 // (DBL_MAX - 1 << (1023 - 105)) + (1 << (1023 - 53) + 0) = DBL_MAX + 3404 // 1.11111... << (1023 - 52) 3405 std::make_tuple(0x7fefffffffffffffull, 0xf950000000000000ull, 3406 0x7c90000000000000ull, 0, 0x7fefffffffffffffull, 3407 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven), 3408 // TODO: change 0xf950000000000000 to 0xf940000000000000, when 3409 // semPPCDoubleDoubleLegacy is gone. 3410 // (1 << (1023 - 53) + 0) + (DBL_MAX - 1 << (1023 - 105)) = DBL_MAX + 3411 // 1.11111... << (1023 - 52) 3412 std::make_tuple(0x7c90000000000000ull, 0, 0x7fefffffffffffffull, 3413 0xf950000000000000ull, 0x7fefffffffffffffull, 3414 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven), 3415 }; 3416 3417 for (auto Tp : Data) { 3418 uint64_t Op1[2], Op2[2], Expected[2]; 3419 APFloat::roundingMode RM; 3420 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp; 3421 3422 { 3423 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 3424 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 3425 A1.add(A2, RM); 3426 3427 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0]) 3428 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], 3429 Op2[0], Op2[1]) 3430 .str(); 3431 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1]) 3432 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], 3433 Op2[0], Op2[1]) 3434 .str(); 3435 } 3436 { 3437 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 3438 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 3439 A2.add(A1, RM); 3440 3441 EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0]) 3442 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1], 3443 Op1[0], Op1[1]) 3444 .str(); 3445 EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1]) 3446 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1], 3447 Op1[0], Op1[1]) 3448 .str(); 3449 } 3450 } 3451 } 3452 3453 TEST(APFloatTest, PPCDoubleDoubleSubtract) { 3454 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, 3455 uint64_t, APFloat::roundingMode>; 3456 DataType Data[] = { 3457 // (1 + 0) - (-1e-105 + 0) = (1 + 1e-105) 3458 std::make_tuple(0x3ff0000000000000ull, 0, 0xb960000000000000ull, 0, 3459 0x3ff0000000000000ull, 0x3960000000000000ull, 3460 APFloat::rmNearestTiesToEven), 3461 // (1 + 0) - (-1e-106 + 0) = (1 + 1e-106) 3462 std::make_tuple(0x3ff0000000000000ull, 0, 0xb950000000000000ull, 0, 3463 0x3ff0000000000000ull, 0x3950000000000000ull, 3464 APFloat::rmNearestTiesToEven), 3465 }; 3466 3467 for (auto Tp : Data) { 3468 uint64_t Op1[2], Op2[2], Expected[2]; 3469 APFloat::roundingMode RM; 3470 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp; 3471 3472 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 3473 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 3474 A1.subtract(A2, RM); 3475 3476 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0]) 3477 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0], 3478 Op2[1]) 3479 .str(); 3480 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1]) 3481 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0], 3482 Op2[1]) 3483 .str(); 3484 } 3485 } 3486 3487 TEST(APFloatTest, PPCDoubleDoubleMultiplySpecial) { 3488 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, 3489 APFloat::fltCategory, APFloat::roundingMode>; 3490 DataType Data[] = { 3491 // fcNaN * fcNaN = fcNaN 3492 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0, 3493 APFloat::fcNaN, APFloat::rmNearestTiesToEven), 3494 // fcNaN * fcZero = fcNaN 3495 std::make_tuple(0x7ff8000000000000ull, 0, 0, 0, APFloat::fcNaN, 3496 APFloat::rmNearestTiesToEven), 3497 // fcNaN * fcInfinity = fcNaN 3498 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff0000000000000ull, 0, 3499 APFloat::fcNaN, APFloat::rmNearestTiesToEven), 3500 // fcNaN * fcNormal = fcNaN 3501 std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0, 3502 APFloat::fcNaN, APFloat::rmNearestTiesToEven), 3503 // fcInfinity * fcInfinity = fcInfinity 3504 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0, 3505 APFloat::fcInfinity, APFloat::rmNearestTiesToEven), 3506 // fcInfinity * fcZero = fcNaN 3507 std::make_tuple(0x7ff0000000000000ull, 0, 0, 0, APFloat::fcNaN, 3508 APFloat::rmNearestTiesToEven), 3509 // fcInfinity * fcNormal = fcInfinity 3510 std::make_tuple(0x7ff0000000000000ull, 0, 0x3ff0000000000000ull, 0, 3511 APFloat::fcInfinity, APFloat::rmNearestTiesToEven), 3512 // fcZero * fcZero = fcZero 3513 std::make_tuple(0, 0, 0, 0, APFloat::fcZero, 3514 APFloat::rmNearestTiesToEven), 3515 // fcZero * fcNormal = fcZero 3516 std::make_tuple(0, 0, 0x3ff0000000000000ull, 0, APFloat::fcZero, 3517 APFloat::rmNearestTiesToEven), 3518 }; 3519 3520 for (auto Tp : Data) { 3521 uint64_t Op1[2], Op2[2]; 3522 APFloat::fltCategory Expected; 3523 APFloat::roundingMode RM; 3524 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp; 3525 3526 { 3527 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 3528 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 3529 A1.multiply(A2, RM); 3530 3531 EXPECT_EQ(Expected, A1.getCategory()) 3532 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1], 3533 Op2[0], Op2[1]) 3534 .str(); 3535 } 3536 { 3537 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 3538 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 3539 A2.multiply(A1, RM); 3540 3541 EXPECT_EQ(Expected, A2.getCategory()) 3542 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1], 3543 Op1[0], Op1[1]) 3544 .str(); 3545 } 3546 } 3547 } 3548 3549 TEST(APFloatTest, PPCDoubleDoubleMultiply) { 3550 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, 3551 uint64_t, APFloat::roundingMode>; 3552 DataType Data[] = { 3553 // 1/3 * 3 = 1.0 3554 std::make_tuple(0x3fd5555555555555ull, 0x3c75555555555556ull, 3555 0x4008000000000000ull, 0, 0x3ff0000000000000ull, 0, 3556 APFloat::rmNearestTiesToEven), 3557 // (1 + epsilon) * (1 + 0) = fcZero 3558 std::make_tuple(0x3ff0000000000000ull, 0x0000000000000001ull, 3559 0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 3560 0x0000000000000001ull, APFloat::rmNearestTiesToEven), 3561 // (1 + epsilon) * (1 + epsilon) = 1 + 2 * epsilon 3562 std::make_tuple(0x3ff0000000000000ull, 0x0000000000000001ull, 3563 0x3ff0000000000000ull, 0x0000000000000001ull, 3564 0x3ff0000000000000ull, 0x0000000000000002ull, 3565 APFloat::rmNearestTiesToEven), 3566 // -(1 + epsilon) * (1 + epsilon) = -1 3567 std::make_tuple(0xbff0000000000000ull, 0x0000000000000001ull, 3568 0x3ff0000000000000ull, 0x0000000000000001ull, 3569 0xbff0000000000000ull, 0, APFloat::rmNearestTiesToEven), 3570 // (0.5 + 0) * (1 + 2 * epsilon) = 0.5 + epsilon 3571 std::make_tuple(0x3fe0000000000000ull, 0, 0x3ff0000000000000ull, 3572 0x0000000000000002ull, 0x3fe0000000000000ull, 3573 0x0000000000000001ull, APFloat::rmNearestTiesToEven), 3574 // (0.5 + 0) * (1 + epsilon) = 0.5 3575 std::make_tuple(0x3fe0000000000000ull, 0, 0x3ff0000000000000ull, 3576 0x0000000000000001ull, 0x3fe0000000000000ull, 0, 3577 APFloat::rmNearestTiesToEven), 3578 // __LDBL_MAX__ * (1 + 1 << 106) = inf 3579 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 3580 0x3ff0000000000000ull, 0x3950000000000000ull, 3581 0x7ff0000000000000ull, 0, APFloat::rmNearestTiesToEven), 3582 // __LDBL_MAX__ * (1 + 1 << 107) > __LDBL_MAX__, but not inf, yes =_=||| 3583 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 3584 0x3ff0000000000000ull, 0x3940000000000000ull, 3585 0x7fefffffffffffffull, 0x7c8fffffffffffffull, 3586 APFloat::rmNearestTiesToEven), 3587 // __LDBL_MAX__ * (1 + 1 << 108) = __LDBL_MAX__ 3588 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 3589 0x3ff0000000000000ull, 0x3930000000000000ull, 3590 0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 3591 APFloat::rmNearestTiesToEven), 3592 }; 3593 3594 for (auto Tp : Data) { 3595 uint64_t Op1[2], Op2[2], Expected[2]; 3596 APFloat::roundingMode RM; 3597 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp; 3598 3599 { 3600 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 3601 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 3602 A1.multiply(A2, RM); 3603 3604 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0]) 3605 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1], 3606 Op2[0], Op2[1]) 3607 .str(); 3608 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1]) 3609 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1], 3610 Op2[0], Op2[1]) 3611 .str(); 3612 } 3613 { 3614 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 3615 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 3616 A2.multiply(A1, RM); 3617 3618 EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0]) 3619 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1], 3620 Op1[0], Op1[1]) 3621 .str(); 3622 EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1]) 3623 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1], 3624 Op1[0], Op1[1]) 3625 .str(); 3626 } 3627 } 3628 } 3629 3630 TEST(APFloatTest, PPCDoubleDoubleDivide) { 3631 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, 3632 uint64_t, APFloat::roundingMode>; 3633 // TODO: Only a sanity check for now. Add more edge cases when the 3634 // double-double algorithm is implemented. 3635 DataType Data[] = { 3636 // 1 / 3 = 1/3 3637 std::make_tuple(0x3ff0000000000000ull, 0, 0x4008000000000000ull, 0, 3638 0x3fd5555555555555ull, 0x3c75555555555556ull, 3639 APFloat::rmNearestTiesToEven), 3640 }; 3641 3642 for (auto Tp : Data) { 3643 uint64_t Op1[2], Op2[2], Expected[2]; 3644 APFloat::roundingMode RM; 3645 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp; 3646 3647 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 3648 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 3649 A1.divide(A2, RM); 3650 3651 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0]) 3652 << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0], 3653 Op2[1]) 3654 .str(); 3655 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1]) 3656 << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0], 3657 Op2[1]) 3658 .str(); 3659 } 3660 } 3661 3662 TEST(APFloatTest, PPCDoubleDoubleRemainder) { 3663 using DataType = 3664 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>; 3665 DataType Data[] = { 3666 // remainder(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53) 3667 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull, 3668 0x3ff4000000000000ull, 0x3ca4000000000000ull, 3669 0x3fe0000000000000ull, 0x3c90000000000000ull), 3670 // remainder(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (-0.5 - 0.5 << 53) 3671 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull, 3672 0x3ffc000000000000ull, 0x3cac000000000000ull, 3673 0xbfe0000000000000ull, 0xbc90000000000000ull), 3674 }; 3675 3676 for (auto Tp : Data) { 3677 uint64_t Op1[2], Op2[2], Expected[2]; 3678 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp; 3679 3680 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 3681 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 3682 A1.remainder(A2); 3683 3684 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0]) 3685 << formatv("remainder({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1], 3686 Op2[0], Op2[1]) 3687 .str(); 3688 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1]) 3689 << formatv("remainder(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], 3690 Op1[1], Op2[0], Op2[1]) 3691 .str(); 3692 } 3693 } 3694 3695 TEST(APFloatTest, PPCDoubleDoubleMod) { 3696 using DataType = 3697 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>; 3698 DataType Data[] = { 3699 // mod(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53) 3700 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull, 3701 0x3ff4000000000000ull, 0x3ca4000000000000ull, 3702 0x3fe0000000000000ull, 0x3c90000000000000ull), 3703 // mod(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (1.25 + 1.25 << 53) 3704 // 0xbc98000000000000 doesn't seem right, but it's what we currently have. 3705 // TODO: investigate 3706 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull, 3707 0x3ffc000000000000ull, 0x3cac000000000000ull, 3708 0x3ff4000000000001ull, 0xbc98000000000000ull), 3709 }; 3710 3711 for (auto Tp : Data) { 3712 uint64_t Op1[2], Op2[2], Expected[2]; 3713 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp; 3714 3715 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 3716 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 3717 A1.mod(A2); 3718 3719 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0]) 3720 << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1], 3721 Op2[0], Op2[1]) 3722 .str(); 3723 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1]) 3724 << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1], 3725 Op2[0], Op2[1]) 3726 .str(); 3727 } 3728 } 3729 3730 TEST(APFloatTest, PPCDoubleDoubleFMA) { 3731 // Sanity check for now. 3732 APFloat A(APFloat::PPCDoubleDouble(), "2"); 3733 A.fusedMultiplyAdd(APFloat(APFloat::PPCDoubleDouble(), "3"), 3734 APFloat(APFloat::PPCDoubleDouble(), "4"), 3735 APFloat::rmNearestTiesToEven); 3736 EXPECT_EQ(APFloat::cmpEqual, 3737 APFloat(APFloat::PPCDoubleDouble(), "10").compare(A)); 3738 } 3739 3740 TEST(APFloatTest, PPCDoubleDoubleRoundToIntegral) { 3741 { 3742 APFloat A(APFloat::PPCDoubleDouble(), "1.5"); 3743 A.roundToIntegral(APFloat::rmNearestTiesToEven); 3744 EXPECT_EQ(APFloat::cmpEqual, 3745 APFloat(APFloat::PPCDoubleDouble(), "2").compare(A)); 3746 } 3747 { 3748 APFloat A(APFloat::PPCDoubleDouble(), "2.5"); 3749 A.roundToIntegral(APFloat::rmNearestTiesToEven); 3750 EXPECT_EQ(APFloat::cmpEqual, 3751 APFloat(APFloat::PPCDoubleDouble(), "2").compare(A)); 3752 } 3753 } 3754 3755 TEST(APFloatTest, PPCDoubleDoubleCompare) { 3756 using DataType = 3757 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, APFloat::cmpResult>; 3758 3759 DataType Data[] = { 3760 // (1 + 0) = (1 + 0) 3761 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0, 3762 APFloat::cmpEqual), 3763 // (1 + 0) < (1.00...1 + 0) 3764 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0, 3765 APFloat::cmpLessThan), 3766 // (1.00...1 + 0) > (1 + 0) 3767 std::make_tuple(0x3ff0000000000001ull, 0, 0x3ff0000000000000ull, 0, 3768 APFloat::cmpGreaterThan), 3769 // (1 + 0) < (1 + epsilon) 3770 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 3771 0x0000000000000001ull, APFloat::cmpLessThan), 3772 // NaN != NaN 3773 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0, 3774 APFloat::cmpUnordered), 3775 // (1 + 0) != NaN 3776 std::make_tuple(0x3ff0000000000000ull, 0, 0x7ff8000000000000ull, 0, 3777 APFloat::cmpUnordered), 3778 // Inf = Inf 3779 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0, 3780 APFloat::cmpEqual), 3781 }; 3782 3783 for (auto Tp : Data) { 3784 uint64_t Op1[2], Op2[2]; 3785 APFloat::cmpResult Expected; 3786 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp; 3787 3788 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 3789 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 3790 EXPECT_EQ(Expected, A1.compare(A2)) 3791 << formatv("compare(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1], 3792 Op2[0], Op2[1]) 3793 .str(); 3794 } 3795 } 3796 3797 TEST(APFloatTest, PPCDoubleDoubleBitwiseIsEqual) { 3798 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, bool>; 3799 3800 DataType Data[] = { 3801 // (1 + 0) = (1 + 0) 3802 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0, true), 3803 // (1 + 0) != (1.00...1 + 0) 3804 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0, 3805 false), 3806 // NaN = NaN 3807 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0, true), 3808 // NaN != NaN with a different bit pattern 3809 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 3810 0x3ff0000000000000ull, false), 3811 // Inf = Inf 3812 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0, true), 3813 }; 3814 3815 for (auto Tp : Data) { 3816 uint64_t Op1[2], Op2[2]; 3817 bool Expected; 3818 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp; 3819 3820 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 3821 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 3822 EXPECT_EQ(Expected, A1.bitwiseIsEqual(A2)) 3823 << formatv("({0:x} + {1:x}) = ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0], 3824 Op2[1]) 3825 .str(); 3826 } 3827 } 3828 3829 TEST(APFloatTest, PPCDoubleDoubleHashValue) { 3830 uint64_t Data1[] = {0x3ff0000000000001ull, 0x0000000000000001ull}; 3831 uint64_t Data2[] = {0x3ff0000000000001ull, 0}; 3832 // The hash values are *hopefully* different. 3833 EXPECT_NE( 3834 hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data1))), 3835 hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data2)))); 3836 } 3837 3838 TEST(APFloatTest, PPCDoubleDoubleChangeSign) { 3839 uint64_t Data[] = { 3840 0x400f000000000000ull, 0xbcb0000000000000ull, 3841 }; 3842 APFloat Float(APFloat::PPCDoubleDouble(), APInt(128, 2, Data)); 3843 { 3844 APFloat Actual = 3845 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "1")); 3846 EXPECT_EQ(0x400f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]); 3847 EXPECT_EQ(0xbcb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]); 3848 } 3849 { 3850 APFloat Actual = 3851 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "-1")); 3852 EXPECT_EQ(0xc00f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]); 3853 EXPECT_EQ(0x3cb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]); 3854 } 3855 } 3856 3857 TEST(APFloatTest, PPCDoubleDoubleFactories) { 3858 { 3859 uint64_t Data[] = { 3860 0, 0, 3861 }; 3862 EXPECT_EQ(APInt(128, 2, Data), 3863 APFloat::getZero(APFloat::PPCDoubleDouble()).bitcastToAPInt()); 3864 } 3865 { 3866 uint64_t Data[] = { 3867 0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 3868 }; 3869 EXPECT_EQ(APInt(128, 2, Data), 3870 APFloat::getLargest(APFloat::PPCDoubleDouble()).bitcastToAPInt()); 3871 } 3872 { 3873 uint64_t Data[] = { 3874 0x0000000000000001ull, 0, 3875 }; 3876 EXPECT_EQ( 3877 APInt(128, 2, Data), 3878 APFloat::getSmallest(APFloat::PPCDoubleDouble()).bitcastToAPInt()); 3879 } 3880 { 3881 uint64_t Data[] = {0x0360000000000000ull, 0}; 3882 EXPECT_EQ(APInt(128, 2, Data), 3883 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble()) 3884 .bitcastToAPInt()); 3885 } 3886 { 3887 uint64_t Data[] = { 3888 0x8000000000000000ull, 0x0000000000000000ull, 3889 }; 3890 EXPECT_EQ( 3891 APInt(128, 2, Data), 3892 APFloat::getZero(APFloat::PPCDoubleDouble(), true).bitcastToAPInt()); 3893 } 3894 { 3895 uint64_t Data[] = { 3896 0xffefffffffffffffull, 0xfc8ffffffffffffeull, 3897 }; 3898 EXPECT_EQ( 3899 APInt(128, 2, Data), 3900 APFloat::getLargest(APFloat::PPCDoubleDouble(), true).bitcastToAPInt()); 3901 } 3902 { 3903 uint64_t Data[] = { 3904 0x8000000000000001ull, 0x0000000000000000ull, 3905 }; 3906 EXPECT_EQ(APInt(128, 2, Data), 3907 APFloat::getSmallest(APFloat::PPCDoubleDouble(), true) 3908 .bitcastToAPInt()); 3909 } 3910 { 3911 uint64_t Data[] = { 3912 0x8360000000000000ull, 0x0000000000000000ull, 3913 }; 3914 EXPECT_EQ(APInt(128, 2, Data), 3915 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble(), true) 3916 .bitcastToAPInt()); 3917 } 3918 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isSmallest()); 3919 EXPECT_TRUE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isLargest()); 3920 } 3921 3922 TEST(APFloatTest, PPCDoubleDoubleIsDenormal) { 3923 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isDenormal()); 3924 EXPECT_FALSE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isDenormal()); 3925 EXPECT_FALSE( 3926 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble()).isDenormal()); 3927 { 3928 // (4 + 3) is not normalized 3929 uint64_t Data[] = { 3930 0x4010000000000000ull, 0x4008000000000000ull, 3931 }; 3932 EXPECT_TRUE( 3933 APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data)).isDenormal()); 3934 } 3935 } 3936 3937 TEST(APFloatTest, PPCDoubleDoubleScalbn) { 3938 // 3.0 + 3.0 << 53 3939 uint64_t Input[] = { 3940 0x4008000000000000ull, 0x3cb8000000000000ull, 3941 }; 3942 APFloat Result = 3943 scalbn(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), 1, 3944 APFloat::rmNearestTiesToEven); 3945 // 6.0 + 6.0 << 53 3946 EXPECT_EQ(0x4018000000000000ull, Result.bitcastToAPInt().getRawData()[0]); 3947 EXPECT_EQ(0x3cc8000000000000ull, Result.bitcastToAPInt().getRawData()[1]); 3948 } 3949 3950 TEST(APFloatTest, PPCDoubleDoubleFrexp) { 3951 // 3.0 + 3.0 << 53 3952 uint64_t Input[] = { 3953 0x4008000000000000ull, 0x3cb8000000000000ull, 3954 }; 3955 int Exp; 3956 // 0.75 + 0.75 << 53 3957 APFloat Result = 3958 frexp(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), Exp, 3959 APFloat::rmNearestTiesToEven); 3960 EXPECT_EQ(2, Exp); 3961 EXPECT_EQ(0x3fe8000000000000ull, Result.bitcastToAPInt().getRawData()[0]); 3962 EXPECT_EQ(0x3c98000000000000ull, Result.bitcastToAPInt().getRawData()[1]); 3963 } 3964 } 3965