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