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