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, fromStringSpecials) { 923 const fltSemantics &Sem = APFloat::IEEEdouble(); 924 const unsigned Precision = 53; 925 const unsigned PayloadBits = Precision - 2; 926 uint64_t PayloadMask = (uint64_t(1) << PayloadBits) - uint64_t(1); 927 928 uint64_t NaNPayloads[] = { 929 0, 930 1, 931 123, 932 0xDEADBEEF, 933 uint64_t(-2), 934 uint64_t(1) << PayloadBits, // overflow bit 935 uint64_t(1) << (PayloadBits - 1), // signaling bit 936 uint64_t(1) << (PayloadBits - 2) // highest possible bit 937 }; 938 939 // Convert payload integer to decimal string representation. 940 std::string NaNPayloadDecStrings[array_lengthof(NaNPayloads)]; 941 for (size_t I = 0; I < array_lengthof(NaNPayloads); ++I) 942 NaNPayloadDecStrings[I] = utostr(NaNPayloads[I]); 943 944 // Convert payload integer to hexadecimal string representation. 945 std::string NaNPayloadHexStrings[array_lengthof(NaNPayloads)]; 946 for (size_t I = 0; I < array_lengthof(NaNPayloads); ++I) 947 NaNPayloadHexStrings[I] = "0x" + utohexstr(NaNPayloads[I]); 948 949 // Fix payloads to expected result. 950 for (uint64_t &Payload : NaNPayloads) 951 Payload &= PayloadMask; 952 953 // Signaling NaN must have a non-zero payload. In case a zero payload is 954 // requested, a default arbitrary payload is set instead. Save this payload 955 // for testing. 956 const uint64_t SNaNDefaultPayload = 957 APFloat::getSNaN(Sem).bitcastToAPInt().getZExtValue() & PayloadMask; 958 959 // Negative sign prefix (or none - for positive). 960 const char Signs[] = {0, '-'}; 961 962 // "Signaling" prefix (or none - for "Quiet"). 963 const char NaNTypes[] = {0, 's', 'S'}; 964 965 const StringRef NaNStrings[] = {"nan", "NaN"}; 966 for (StringRef NaNStr : NaNStrings) 967 for (char TypeChar : NaNTypes) { 968 bool Signaling = (TypeChar == 's' || TypeChar == 'S'); 969 970 for (size_t J = 0; J < array_lengthof(NaNPayloads); ++J) { 971 uint64_t Payload = (Signaling && !NaNPayloads[J]) ? SNaNDefaultPayload 972 : NaNPayloads[J]; 973 std::string &PayloadDec = NaNPayloadDecStrings[J]; 974 std::string &PayloadHex = NaNPayloadHexStrings[J]; 975 976 for (char SignChar : Signs) { 977 bool Negative = (SignChar == '-'); 978 979 std::string TestStrings[5]; 980 size_t NumTestStrings = 0; 981 982 std::string Prefix; 983 if (SignChar) 984 Prefix += SignChar; 985 if (TypeChar) 986 Prefix += TypeChar; 987 Prefix += NaNStr; 988 989 // Test without any paylod. 990 if (!Payload) 991 TestStrings[NumTestStrings++] = Prefix; 992 993 // Test with the payload as a suffix. 994 TestStrings[NumTestStrings++] = Prefix + PayloadDec; 995 TestStrings[NumTestStrings++] = Prefix + PayloadHex; 996 997 // Test with the payload inside parentheses. 998 TestStrings[NumTestStrings++] = Prefix + '(' + PayloadDec + ')'; 999 TestStrings[NumTestStrings++] = Prefix + '(' + PayloadHex + ')'; 1000 1001 for (size_t K = 0; K < NumTestStrings; ++K) { 1002 StringRef TestStr = TestStrings[K]; 1003 1004 APFloat F(Sem); 1005 bool HasError = !F.convertFromString( 1006 TestStr, llvm::APFloat::rmNearestTiesToEven); 1007 EXPECT_FALSE(HasError); 1008 EXPECT_TRUE(F.isNaN()); 1009 EXPECT_EQ(Signaling, F.isSignaling()); 1010 EXPECT_EQ(Negative, F.isNegative()); 1011 uint64_t PayloadResult = 1012 F.bitcastToAPInt().getZExtValue() & PayloadMask; 1013 EXPECT_EQ(Payload, PayloadResult); 1014 } 1015 } 1016 } 1017 } 1018 1019 const StringRef InfStrings[] = {"inf", "INFINITY", "+Inf", 1020 "-inf", "-INFINITY", "-Inf"}; 1021 for (StringRef InfStr : InfStrings) { 1022 bool Negative = InfStr.front() == '-'; 1023 1024 APFloat F(Sem); 1025 bool HasError = 1026 !F.convertFromString(InfStr, llvm::APFloat::rmNearestTiesToEven); 1027 EXPECT_FALSE(HasError); 1028 EXPECT_TRUE(F.isInfinity()); 1029 EXPECT_EQ(Negative, F.isNegative()); 1030 uint64_t PayloadResult = F.bitcastToAPInt().getZExtValue() & PayloadMask; 1031 EXPECT_EQ(UINT64_C(0), PayloadResult); 1032 } 1033 } 1034 1035 TEST(APFloatTest, fromToStringSpecials) { 1036 auto expects = [] (const char *first, const char *second) { 1037 std::string roundtrip = convertToString(convertToDoubleFromString(second), 0, 3); 1038 EXPECT_STREQ(first, roundtrip.c_str()); 1039 }; 1040 expects("+Inf", "+Inf"); 1041 expects("+Inf", "INFINITY"); 1042 expects("+Inf", "inf"); 1043 expects("-Inf", "-Inf"); 1044 expects("-Inf", "-INFINITY"); 1045 expects("-Inf", "-inf"); 1046 expects("NaN", "NaN"); 1047 expects("NaN", "nan"); 1048 expects("NaN", "-NaN"); 1049 expects("NaN", "-nan"); 1050 } 1051 1052 TEST(APFloatTest, fromHexadecimalString) { 1053 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble()); 1054 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p0").convertToDouble()); 1055 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p0").convertToDouble()); 1056 1057 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p+0").convertToDouble()); 1058 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p+0").convertToDouble()); 1059 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p+0").convertToDouble()); 1060 1061 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble(), "0x1p-0").convertToDouble()); 1062 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble(), "+0x1p-0").convertToDouble()); 1063 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble(), "-0x1p-0").convertToDouble()); 1064 1065 1066 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p1").convertToDouble()); 1067 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p1").convertToDouble()); 1068 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p1").convertToDouble()); 1069 1070 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble(), "0x1p+1").convertToDouble()); 1071 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble(), "+0x1p+1").convertToDouble()); 1072 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble(), "-0x1p+1").convertToDouble()); 1073 1074 EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble(), "0x1p-1").convertToDouble()); 1075 EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble(), "+0x1p-1").convertToDouble()); 1076 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble(), "-0x1p-1").convertToDouble()); 1077 1078 1079 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p1").convertToDouble()); 1080 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p1").convertToDouble()); 1081 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p1").convertToDouble()); 1082 1083 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble(), "0x1.8p+1").convertToDouble()); 1084 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble(), "+0x1.8p+1").convertToDouble()); 1085 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble(), "-0x1.8p+1").convertToDouble()); 1086 1087 EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble(), "0x1.8p-1").convertToDouble()); 1088 EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble(), "+0x1.8p-1").convertToDouble()); 1089 EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble(), "-0x1.8p-1").convertToDouble()); 1090 1091 1092 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p1").convertToDouble()); 1093 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p1").convertToDouble()); 1094 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p1").convertToDouble()); 1095 1096 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p+1").convertToDouble()); 1097 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p+1").convertToDouble()); 1098 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p+1").convertToDouble()); 1099 1100 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(), "0x1000.000p-1").convertToDouble()); 1101 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000.000p-1").convertToDouble()); 1102 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000.000p-1").convertToDouble()); 1103 1104 1105 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p1").convertToDouble()); 1106 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p1").convertToDouble()); 1107 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p1").convertToDouble()); 1108 1109 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble(), "0x1000p+1").convertToDouble()); 1110 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble(), "+0x1000p+1").convertToDouble()); 1111 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble(), "-0x1000p+1").convertToDouble()); 1112 1113 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble(), "0x1000p-1").convertToDouble()); 1114 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble(), "+0x1000p-1").convertToDouble()); 1115 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble(), "-0x1000p-1").convertToDouble()); 1116 1117 1118 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p10").convertToDouble()); 1119 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p10").convertToDouble()); 1120 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p10").convertToDouble()); 1121 1122 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble(), "0x10p+10").convertToDouble()); 1123 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble(), "+0x10p+10").convertToDouble()); 1124 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble(), "-0x10p+10").convertToDouble()); 1125 1126 EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble(), "0x10p-10").convertToDouble()); 1127 EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble(), "+0x10p-10").convertToDouble()); 1128 EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble(), "-0x10p-10").convertToDouble()); 1129 1130 EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble(), "0x1.1p0").convertToDouble()); 1131 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble(), "0x1p0").convertToDouble()); 1132 1133 EXPECT_EQ(convertToDoubleFromString("0x1p-150"), 1134 convertToDoubleFromString("+0x800000000000000001.p-221")); 1135 EXPECT_EQ(2251799813685248.5, 1136 convertToDoubleFromString("0x80000000000004000000.010p-28")); 1137 } 1138 1139 TEST(APFloatTest, toString) { 1140 ASSERT_EQ("10", convertToString(10.0, 6, 3)); 1141 ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0)); 1142 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2)); 1143 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2)); 1144 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1)); 1145 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2)); 1146 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2)); 1147 ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1)); 1148 ASSERT_EQ("0.78539816339744828", convertToString(0.78539816339744830961, 0, 3)); 1149 ASSERT_EQ("4.9406564584124654E-324", convertToString(4.9406564584124654e-324, 0, 3)); 1150 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1)); 1151 ASSERT_EQ("8.7318340000000001E+2", convertToString(873.1834, 0, 0)); 1152 ASSERT_EQ("1.7976931348623157E+308", convertToString(1.7976931348623157E+308, 0, 0)); 1153 ASSERT_EQ("10", convertToString(10.0, 6, 3, false)); 1154 ASSERT_EQ("1.000000e+01", convertToString(10.0, 6, 0, false)); 1155 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2, false)); 1156 ASSERT_EQ("1.0100e+04", convertToString(1.01E+4, 4, 2, false)); 1157 ASSERT_EQ("1.01000e+04", convertToString(1.01E+4, 5, 1, false)); 1158 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2, false)); 1159 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2, false)); 1160 ASSERT_EQ("1.01000e-02", convertToString(1.01E-2, 5, 1, false)); 1161 ASSERT_EQ("0.78539816339744828", 1162 convertToString(0.78539816339744830961, 0, 3, false)); 1163 ASSERT_EQ("4.94065645841246540e-324", 1164 convertToString(4.9406564584124654e-324, 0, 3, false)); 1165 ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1, false)); 1166 ASSERT_EQ("8.73183400000000010e+02", convertToString(873.1834, 0, 0, false)); 1167 ASSERT_EQ("1.79769313486231570e+308", 1168 convertToString(1.7976931348623157E+308, 0, 0, false)); 1169 1170 { 1171 SmallString<64> Str; 1172 APFloat UnnormalZero(APFloat::x87DoubleExtended(), APInt(80, {0, 1})); 1173 UnnormalZero.toString(Str); 1174 ASSERT_EQ("NaN", Str); 1175 } 1176 } 1177 1178 TEST(APFloatTest, toInteger) { 1179 bool isExact = false; 1180 APSInt result(5, /*isUnsigned=*/true); 1181 1182 EXPECT_EQ(APFloat::opOK, 1183 APFloat(APFloat::IEEEdouble(), "10") 1184 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 1185 EXPECT_TRUE(isExact); 1186 EXPECT_EQ(APSInt(APInt(5, 10), true), result); 1187 1188 EXPECT_EQ(APFloat::opInvalidOp, 1189 APFloat(APFloat::IEEEdouble(), "-10") 1190 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 1191 EXPECT_FALSE(isExact); 1192 EXPECT_EQ(APSInt::getMinValue(5, true), result); 1193 1194 EXPECT_EQ(APFloat::opInvalidOp, 1195 APFloat(APFloat::IEEEdouble(), "32") 1196 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 1197 EXPECT_FALSE(isExact); 1198 EXPECT_EQ(APSInt::getMaxValue(5, true), result); 1199 1200 EXPECT_EQ(APFloat::opInexact, 1201 APFloat(APFloat::IEEEdouble(), "7.9") 1202 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 1203 EXPECT_FALSE(isExact); 1204 EXPECT_EQ(APSInt(APInt(5, 7), true), result); 1205 1206 result.setIsUnsigned(false); 1207 EXPECT_EQ(APFloat::opOK, 1208 APFloat(APFloat::IEEEdouble(), "-10") 1209 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 1210 EXPECT_TRUE(isExact); 1211 EXPECT_EQ(APSInt(APInt(5, -10, true), false), result); 1212 1213 EXPECT_EQ(APFloat::opInvalidOp, 1214 APFloat(APFloat::IEEEdouble(), "-17") 1215 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 1216 EXPECT_FALSE(isExact); 1217 EXPECT_EQ(APSInt::getMinValue(5, false), result); 1218 1219 EXPECT_EQ(APFloat::opInvalidOp, 1220 APFloat(APFloat::IEEEdouble(), "16") 1221 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 1222 EXPECT_FALSE(isExact); 1223 EXPECT_EQ(APSInt::getMaxValue(5, false), result); 1224 } 1225 1226 static APInt nanbitsFromAPInt(const fltSemantics &Sem, bool SNaN, bool Negative, 1227 uint64_t payload) { 1228 APInt appayload(64, payload); 1229 if (SNaN) 1230 return APFloat::getSNaN(Sem, Negative, &appayload).bitcastToAPInt(); 1231 else 1232 return APFloat::getQNaN(Sem, Negative, &appayload).bitcastToAPInt(); 1233 } 1234 1235 TEST(APFloatTest, makeNaN) { 1236 const struct { 1237 uint64_t expected; 1238 const fltSemantics &semantics; 1239 bool SNaN; 1240 bool Negative; 1241 uint64_t payload; 1242 } tests[] = { 1243 /* expected semantics SNaN Neg payload */ 1244 { 0x7fc00000ULL, APFloat::IEEEsingle(), false, false, 0x00000000ULL }, 1245 { 0xffc00000ULL, APFloat::IEEEsingle(), false, true, 0x00000000ULL }, 1246 { 0x7fc0ae72ULL, APFloat::IEEEsingle(), false, false, 0x0000ae72ULL }, 1247 { 0x7fffae72ULL, APFloat::IEEEsingle(), false, false, 0xffffae72ULL }, 1248 { 0x7fdaae72ULL, APFloat::IEEEsingle(), false, false, 0x00daae72ULL }, 1249 { 0x7fa00000ULL, APFloat::IEEEsingle(), true, false, 0x00000000ULL }, 1250 { 0xffa00000ULL, APFloat::IEEEsingle(), true, true, 0x00000000ULL }, 1251 { 0x7f80ae72ULL, APFloat::IEEEsingle(), true, false, 0x0000ae72ULL }, 1252 { 0x7fbfae72ULL, APFloat::IEEEsingle(), true, false, 0xffffae72ULL }, 1253 { 0x7f9aae72ULL, APFloat::IEEEsingle(), true, false, 0x001aae72ULL }, 1254 { 0x7ff8000000000000ULL, APFloat::IEEEdouble(), false, false, 0x0000000000000000ULL }, 1255 { 0xfff8000000000000ULL, APFloat::IEEEdouble(), false, true, 0x0000000000000000ULL }, 1256 { 0x7ff800000000ae72ULL, APFloat::IEEEdouble(), false, false, 0x000000000000ae72ULL }, 1257 { 0x7fffffffffffae72ULL, APFloat::IEEEdouble(), false, false, 0xffffffffffffae72ULL }, 1258 { 0x7ffdaaaaaaaaae72ULL, APFloat::IEEEdouble(), false, false, 0x000daaaaaaaaae72ULL }, 1259 { 0x7ff4000000000000ULL, APFloat::IEEEdouble(), true, false, 0x0000000000000000ULL }, 1260 { 0xfff4000000000000ULL, APFloat::IEEEdouble(), true, true, 0x0000000000000000ULL }, 1261 { 0x7ff000000000ae72ULL, APFloat::IEEEdouble(), true, false, 0x000000000000ae72ULL }, 1262 { 0x7ff7ffffffffae72ULL, APFloat::IEEEdouble(), true, false, 0xffffffffffffae72ULL }, 1263 { 0x7ff1aaaaaaaaae72ULL, APFloat::IEEEdouble(), true, false, 0x0001aaaaaaaaae72ULL }, 1264 }; 1265 1266 for (const auto &t : tests) { 1267 ASSERT_EQ(t.expected, nanbitsFromAPInt(t.semantics, t.SNaN, t.Negative, t.payload)); 1268 } 1269 } 1270 1271 #ifdef GTEST_HAS_DEATH_TEST 1272 #ifndef NDEBUG 1273 TEST(APFloatTest, SemanticsDeath) { 1274 EXPECT_DEATH(APFloat(APFloat::IEEEsingle(), 0).convertToDouble(), "Float semantics are not IEEEdouble"); 1275 EXPECT_DEATH(APFloat(APFloat::IEEEdouble(), 0).convertToFloat(), "Float semantics are not IEEEsingle"); 1276 } 1277 #endif 1278 #endif 1279 1280 TEST(APFloatTest, StringDecimalError) { 1281 EXPECT_EQ("Invalid string length", convertToErrorFromString("")); 1282 EXPECT_EQ("String has no digits", convertToErrorFromString("+")); 1283 EXPECT_EQ("String has no digits", convertToErrorFromString("-")); 1284 1285 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("\0", 1))); 1286 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1\0", 2))); 1287 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1" "\0" "2", 3))); 1288 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("1" "\0" "2e1", 5))); 1289 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e\0", 3))); 1290 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e1\0", 4))); 1291 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("1e1" "\0" "2", 5))); 1292 1293 EXPECT_EQ("Invalid character in significand", convertToErrorFromString("1.0f")); 1294 1295 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("..")); 1296 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("..0")); 1297 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("1.0.0")); 1298 } 1299 1300 TEST(APFloatTest, StringDecimalSignificandError) { 1301 EXPECT_EQ("Significand has no digits", convertToErrorFromString( ".")); 1302 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+.")); 1303 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-.")); 1304 1305 1306 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "e")); 1307 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+e")); 1308 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-e")); 1309 1310 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "e1")); 1311 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+e1")); 1312 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-e1")); 1313 1314 EXPECT_EQ("Significand has no digits", convertToErrorFromString( ".e1")); 1315 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+.e1")); 1316 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-.e1")); 1317 1318 1319 EXPECT_EQ("Significand has no digits", convertToErrorFromString( ".e")); 1320 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+.e")); 1321 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-.e")); 1322 } 1323 1324 TEST(APFloatTest, StringHexadecimalError) { 1325 EXPECT_EQ("Invalid string", convertToErrorFromString( "0x")); 1326 EXPECT_EQ("Invalid string", convertToErrorFromString("+0x")); 1327 EXPECT_EQ("Invalid string", convertToErrorFromString("-0x")); 1328 1329 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0")); 1330 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0")); 1331 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0")); 1332 1333 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0.")); 1334 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0.")); 1335 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0.")); 1336 1337 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x.0")); 1338 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x.0")); 1339 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x.0")); 1340 1341 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString( "0x0.0")); 1342 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("+0x0.0")); 1343 EXPECT_EQ("Hex strings require an exponent", convertToErrorFromString("-0x0.0")); 1344 1345 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x\0", 3))); 1346 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1\0", 4))); 1347 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1" "\0" "2", 5))); 1348 EXPECT_EQ("Invalid character in significand", convertToErrorFromString(StringRef("0x1" "\0" "2p1", 7))); 1349 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p\0", 5))); 1350 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p1\0", 6))); 1351 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString(StringRef("0x1p1" "\0" "2", 7))); 1352 1353 EXPECT_EQ("Invalid character in exponent", convertToErrorFromString("0x1p0f")); 1354 1355 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x..p1")); 1356 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x..0p1")); 1357 EXPECT_EQ("String contains multiple dots", convertToErrorFromString("0x1.0.0p1")); 1358 } 1359 1360 TEST(APFloatTest, StringHexadecimalSignificandError) { 1361 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.")); 1362 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.")); 1363 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.")); 1364 1365 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp")); 1366 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp")); 1367 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp")); 1368 1369 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp+")); 1370 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp+")); 1371 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp+")); 1372 1373 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0xp-")); 1374 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0xp-")); 1375 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0xp-")); 1376 1377 1378 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p")); 1379 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p")); 1380 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p")); 1381 1382 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p+")); 1383 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p+")); 1384 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p+")); 1385 1386 EXPECT_EQ("Significand has no digits", convertToErrorFromString( "0x.p-")); 1387 EXPECT_EQ("Significand has no digits", convertToErrorFromString("+0x.p-")); 1388 EXPECT_EQ("Significand has no digits", convertToErrorFromString("-0x.p-")); 1389 } 1390 1391 TEST(APFloatTest, StringHexadecimalExponentError) { 1392 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p")); 1393 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p")); 1394 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p")); 1395 1396 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p+")); 1397 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p+")); 1398 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p+")); 1399 1400 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1p-")); 1401 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1p-")); 1402 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1p-")); 1403 1404 1405 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p")); 1406 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p")); 1407 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p")); 1408 1409 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p+")); 1410 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p+")); 1411 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p+")); 1412 1413 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.p-")); 1414 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.p-")); 1415 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.p-")); 1416 1417 1418 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p")); 1419 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p")); 1420 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p")); 1421 1422 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p+")); 1423 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p+")); 1424 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p+")); 1425 1426 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x.1p-")); 1427 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x.1p-")); 1428 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x.1p-")); 1429 1430 1431 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p")); 1432 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p")); 1433 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p")); 1434 1435 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p+")); 1436 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p+")); 1437 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p+")); 1438 1439 EXPECT_EQ("Exponent has no digits", convertToErrorFromString( "0x1.1p-")); 1440 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("+0x1.1p-")); 1441 EXPECT_EQ("Exponent has no digits", convertToErrorFromString("-0x1.1p-")); 1442 } 1443 1444 TEST(APFloatTest, exactInverse) { 1445 APFloat inv(0.0f); 1446 1447 // Trivial operation. 1448 EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv)); 1449 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5))); 1450 EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv)); 1451 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f))); 1452 EXPECT_TRUE(APFloat(APFloat::IEEEquad(), "2.0").getExactInverse(&inv)); 1453 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad(), "0.5"))); 1454 EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble(), "2.0").getExactInverse(&inv)); 1455 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble(), "0.5"))); 1456 EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended(), "2.0").getExactInverse(&inv)); 1457 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended(), "0.5"))); 1458 1459 // FLT_MIN 1460 EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv)); 1461 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f))); 1462 1463 // Large float, inverse is a denormal. 1464 EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(nullptr)); 1465 // Zero 1466 EXPECT_FALSE(APFloat(0.0).getExactInverse(nullptr)); 1467 // Denormalized float 1468 EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(nullptr)); 1469 } 1470 1471 TEST(APFloatTest, roundToIntegral) { 1472 APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble())), P(0.0); 1473 1474 P = T; 1475 P.roundToIntegral(APFloat::rmTowardZero); 1476 EXPECT_EQ(-0.0, P.convertToDouble()); 1477 P = T; 1478 P.roundToIntegral(APFloat::rmTowardNegative); 1479 EXPECT_EQ(-1.0, P.convertToDouble()); 1480 P = T; 1481 P.roundToIntegral(APFloat::rmTowardPositive); 1482 EXPECT_EQ(-0.0, P.convertToDouble()); 1483 P = T; 1484 P.roundToIntegral(APFloat::rmNearestTiesToEven); 1485 EXPECT_EQ(-0.0, P.convertToDouble()); 1486 1487 P = S; 1488 P.roundToIntegral(APFloat::rmTowardZero); 1489 EXPECT_EQ(3.0, P.convertToDouble()); 1490 P = S; 1491 P.roundToIntegral(APFloat::rmTowardNegative); 1492 EXPECT_EQ(3.0, P.convertToDouble()); 1493 P = S; 1494 P.roundToIntegral(APFloat::rmTowardPositive); 1495 EXPECT_EQ(4.0, P.convertToDouble()); 1496 P = S; 1497 P.roundToIntegral(APFloat::rmNearestTiesToEven); 1498 EXPECT_EQ(3.0, P.convertToDouble()); 1499 1500 P = R; 1501 P.roundToIntegral(APFloat::rmTowardZero); 1502 EXPECT_EQ(R.convertToDouble(), P.convertToDouble()); 1503 P = R; 1504 P.roundToIntegral(APFloat::rmTowardNegative); 1505 EXPECT_EQ(R.convertToDouble(), P.convertToDouble()); 1506 P = R; 1507 P.roundToIntegral(APFloat::rmTowardPositive); 1508 EXPECT_EQ(R.convertToDouble(), P.convertToDouble()); 1509 P = R; 1510 P.roundToIntegral(APFloat::rmNearestTiesToEven); 1511 EXPECT_EQ(R.convertToDouble(), P.convertToDouble()); 1512 1513 P = APFloat::getZero(APFloat::IEEEdouble()); 1514 P.roundToIntegral(APFloat::rmTowardZero); 1515 EXPECT_EQ(0.0, P.convertToDouble()); 1516 P = APFloat::getZero(APFloat::IEEEdouble(), true); 1517 P.roundToIntegral(APFloat::rmTowardZero); 1518 EXPECT_EQ(-0.0, P.convertToDouble()); 1519 P = APFloat::getNaN(APFloat::IEEEdouble()); 1520 P.roundToIntegral(APFloat::rmTowardZero); 1521 EXPECT_TRUE(std::isnan(P.convertToDouble())); 1522 P = APFloat::getInf(APFloat::IEEEdouble()); 1523 P.roundToIntegral(APFloat::rmTowardZero); 1524 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() > 0.0); 1525 P = APFloat::getInf(APFloat::IEEEdouble(), true); 1526 P.roundToIntegral(APFloat::rmTowardZero); 1527 EXPECT_TRUE(std::isinf(P.convertToDouble()) && P.convertToDouble() < 0.0); 1528 1529 APFloat::opStatus St; 1530 1531 P = APFloat::getNaN(APFloat::IEEEdouble()); 1532 St = P.roundToIntegral(APFloat::rmTowardZero); 1533 EXPECT_TRUE(P.isNaN()); 1534 EXPECT_FALSE(P.isNegative()); 1535 EXPECT_EQ(APFloat::opOK, St); 1536 1537 P = APFloat::getNaN(APFloat::IEEEdouble(), true); 1538 St = P.roundToIntegral(APFloat::rmTowardZero); 1539 EXPECT_TRUE(P.isNaN()); 1540 EXPECT_TRUE(P.isNegative()); 1541 EXPECT_EQ(APFloat::opOK, St); 1542 1543 P = APFloat::getSNaN(APFloat::IEEEdouble()); 1544 St = P.roundToIntegral(APFloat::rmTowardZero); 1545 EXPECT_TRUE(P.isNaN()); 1546 EXPECT_FALSE(P.isSignaling()); 1547 EXPECT_FALSE(P.isNegative()); 1548 EXPECT_EQ(APFloat::opInvalidOp, St); 1549 1550 P = APFloat::getSNaN(APFloat::IEEEdouble(), true); 1551 St = P.roundToIntegral(APFloat::rmTowardZero); 1552 EXPECT_TRUE(P.isNaN()); 1553 EXPECT_FALSE(P.isSignaling()); 1554 EXPECT_TRUE(P.isNegative()); 1555 EXPECT_EQ(APFloat::opInvalidOp, St); 1556 1557 P = APFloat::getInf(APFloat::IEEEdouble()); 1558 St = P.roundToIntegral(APFloat::rmTowardZero); 1559 EXPECT_TRUE(P.isInfinity()); 1560 EXPECT_FALSE(P.isNegative()); 1561 EXPECT_EQ(APFloat::opOK, St); 1562 1563 P = APFloat::getInf(APFloat::IEEEdouble(), true); 1564 St = P.roundToIntegral(APFloat::rmTowardZero); 1565 EXPECT_TRUE(P.isInfinity()); 1566 EXPECT_TRUE(P.isNegative()); 1567 EXPECT_EQ(APFloat::opOK, St); 1568 1569 P = APFloat::getZero(APFloat::IEEEdouble(), false); 1570 St = P.roundToIntegral(APFloat::rmTowardZero); 1571 EXPECT_TRUE(P.isZero()); 1572 EXPECT_FALSE(P.isNegative()); 1573 EXPECT_EQ(APFloat::opOK, St); 1574 1575 P = APFloat::getZero(APFloat::IEEEdouble(), false); 1576 St = P.roundToIntegral(APFloat::rmTowardNegative); 1577 EXPECT_TRUE(P.isZero()); 1578 EXPECT_FALSE(P.isNegative()); 1579 EXPECT_EQ(APFloat::opOK, St); 1580 1581 P = APFloat::getZero(APFloat::IEEEdouble(), true); 1582 St = P.roundToIntegral(APFloat::rmTowardZero); 1583 EXPECT_TRUE(P.isZero()); 1584 EXPECT_TRUE(P.isNegative()); 1585 EXPECT_EQ(APFloat::opOK, St); 1586 1587 P = APFloat::getZero(APFloat::IEEEdouble(), true); 1588 St = P.roundToIntegral(APFloat::rmTowardNegative); 1589 EXPECT_TRUE(P.isZero()); 1590 EXPECT_TRUE(P.isNegative()); 1591 EXPECT_EQ(APFloat::opOK, St); 1592 1593 P = APFloat(1E-100); 1594 St = P.roundToIntegral(APFloat::rmTowardNegative); 1595 EXPECT_TRUE(P.isZero()); 1596 EXPECT_FALSE(P.isNegative()); 1597 EXPECT_EQ(APFloat::opInexact, St); 1598 1599 P = APFloat(1E-100); 1600 St = P.roundToIntegral(APFloat::rmTowardPositive); 1601 EXPECT_EQ(1.0, P.convertToDouble()); 1602 EXPECT_FALSE(P.isNegative()); 1603 EXPECT_EQ(APFloat::opInexact, St); 1604 1605 P = APFloat(-1E-100); 1606 St = P.roundToIntegral(APFloat::rmTowardNegative); 1607 EXPECT_TRUE(P.isNegative()); 1608 EXPECT_EQ(-1.0, P.convertToDouble()); 1609 EXPECT_EQ(APFloat::opInexact, St); 1610 1611 P = APFloat(-1E-100); 1612 St = P.roundToIntegral(APFloat::rmTowardPositive); 1613 EXPECT_TRUE(P.isZero()); 1614 EXPECT_TRUE(P.isNegative()); 1615 EXPECT_EQ(APFloat::opInexact, St); 1616 1617 P = APFloat(10.0); 1618 St = P.roundToIntegral(APFloat::rmTowardZero); 1619 EXPECT_EQ(10.0, P.convertToDouble()); 1620 EXPECT_EQ(APFloat::opOK, St); 1621 1622 P = APFloat(10.5); 1623 St = P.roundToIntegral(APFloat::rmTowardZero); 1624 EXPECT_EQ(10.0, P.convertToDouble()); 1625 EXPECT_EQ(APFloat::opInexact, St); 1626 1627 P = APFloat(10.5); 1628 St = P.roundToIntegral(APFloat::rmTowardPositive); 1629 EXPECT_EQ(11.0, P.convertToDouble()); 1630 EXPECT_EQ(APFloat::opInexact, St); 1631 1632 P = APFloat(10.5); 1633 St = P.roundToIntegral(APFloat::rmTowardNegative); 1634 EXPECT_EQ(10.0, P.convertToDouble()); 1635 EXPECT_EQ(APFloat::opInexact, St); 1636 1637 P = APFloat(10.5); 1638 St = P.roundToIntegral(APFloat::rmNearestTiesToAway); 1639 EXPECT_EQ(11.0, P.convertToDouble()); 1640 EXPECT_EQ(APFloat::opInexact, St); 1641 1642 P = APFloat(10.5); 1643 St = P.roundToIntegral(APFloat::rmNearestTiesToEven); 1644 EXPECT_EQ(10.0, P.convertToDouble()); 1645 EXPECT_EQ(APFloat::opInexact, St); 1646 } 1647 1648 TEST(APFloatTest, isInteger) { 1649 APFloat T(-0.0); 1650 EXPECT_TRUE(T.isInteger()); 1651 T = APFloat(3.14159); 1652 EXPECT_FALSE(T.isInteger()); 1653 T = APFloat::getNaN(APFloat::IEEEdouble()); 1654 EXPECT_FALSE(T.isInteger()); 1655 T = APFloat::getInf(APFloat::IEEEdouble()); 1656 EXPECT_FALSE(T.isInteger()); 1657 T = APFloat::getInf(APFloat::IEEEdouble(), true); 1658 EXPECT_FALSE(T.isInteger()); 1659 T = APFloat::getLargest(APFloat::IEEEdouble()); 1660 EXPECT_TRUE(T.isInteger()); 1661 } 1662 1663 TEST(DoubleAPFloatTest, isInteger) { 1664 APFloat F1(-0.0); 1665 APFloat F2(-0.0); 1666 llvm::detail::DoubleAPFloat T(APFloat::PPCDoubleDouble(), std::move(F1), 1667 std::move(F2)); 1668 EXPECT_TRUE(T.isInteger()); 1669 APFloat F3(3.14159); 1670 APFloat F4(-0.0); 1671 llvm::detail::DoubleAPFloat T2(APFloat::PPCDoubleDouble(), std::move(F3), 1672 std::move(F4)); 1673 EXPECT_FALSE(T2.isInteger()); 1674 APFloat F5(-0.0); 1675 APFloat F6(3.14159); 1676 llvm::detail::DoubleAPFloat T3(APFloat::PPCDoubleDouble(), std::move(F5), 1677 std::move(F6)); 1678 EXPECT_FALSE(T3.isInteger()); 1679 } 1680 1681 TEST(APFloatTest, getLargest) { 1682 EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle()).convertToFloat()); 1683 EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble()).convertToDouble()); 1684 } 1685 1686 TEST(APFloatTest, getSmallest) { 1687 APFloat test = APFloat::getSmallest(APFloat::IEEEsingle(), false); 1688 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x0.000002p-126"); 1689 EXPECT_FALSE(test.isNegative()); 1690 EXPECT_TRUE(test.isFiniteNonZero()); 1691 EXPECT_TRUE(test.isDenormal()); 1692 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1693 1694 test = APFloat::getSmallest(APFloat::IEEEsingle(), true); 1695 expected = APFloat(APFloat::IEEEsingle(), "-0x0.000002p-126"); 1696 EXPECT_TRUE(test.isNegative()); 1697 EXPECT_TRUE(test.isFiniteNonZero()); 1698 EXPECT_TRUE(test.isDenormal()); 1699 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1700 1701 test = APFloat::getSmallest(APFloat::IEEEquad(), false); 1702 expected = APFloat(APFloat::IEEEquad(), "0x0.0000000000000000000000000001p-16382"); 1703 EXPECT_FALSE(test.isNegative()); 1704 EXPECT_TRUE(test.isFiniteNonZero()); 1705 EXPECT_TRUE(test.isDenormal()); 1706 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1707 1708 test = APFloat::getSmallest(APFloat::IEEEquad(), true); 1709 expected = APFloat(APFloat::IEEEquad(), "-0x0.0000000000000000000000000001p-16382"); 1710 EXPECT_TRUE(test.isNegative()); 1711 EXPECT_TRUE(test.isFiniteNonZero()); 1712 EXPECT_TRUE(test.isDenormal()); 1713 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1714 } 1715 1716 TEST(APFloatTest, getSmallestNormalized) { 1717 APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false); 1718 APFloat expected = APFloat(APFloat::IEEEsingle(), "0x1p-126"); 1719 EXPECT_FALSE(test.isNegative()); 1720 EXPECT_TRUE(test.isFiniteNonZero()); 1721 EXPECT_FALSE(test.isDenormal()); 1722 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1723 1724 test = APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true); 1725 expected = APFloat(APFloat::IEEEsingle(), "-0x1p-126"); 1726 EXPECT_TRUE(test.isNegative()); 1727 EXPECT_TRUE(test.isFiniteNonZero()); 1728 EXPECT_FALSE(test.isDenormal()); 1729 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1730 1731 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), false); 1732 expected = APFloat(APFloat::IEEEquad(), "0x1p-16382"); 1733 EXPECT_FALSE(test.isNegative()); 1734 EXPECT_TRUE(test.isFiniteNonZero()); 1735 EXPECT_FALSE(test.isDenormal()); 1736 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1737 1738 test = APFloat::getSmallestNormalized(APFloat::IEEEquad(), true); 1739 expected = APFloat(APFloat::IEEEquad(), "-0x1p-16382"); 1740 EXPECT_TRUE(test.isNegative()); 1741 EXPECT_TRUE(test.isFiniteNonZero()); 1742 EXPECT_FALSE(test.isDenormal()); 1743 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1744 } 1745 1746 TEST(APFloatTest, getZero) { 1747 struct { 1748 const fltSemantics *semantics; 1749 const bool sign; 1750 const unsigned long long bitPattern[2]; 1751 const unsigned bitPatternLength; 1752 } const GetZeroTest[] = { 1753 { &APFloat::IEEEhalf(), false, {0, 0}, 1}, 1754 { &APFloat::IEEEhalf(), true, {0x8000ULL, 0}, 1}, 1755 { &APFloat::IEEEsingle(), false, {0, 0}, 1}, 1756 { &APFloat::IEEEsingle(), true, {0x80000000ULL, 0}, 1}, 1757 { &APFloat::IEEEdouble(), false, {0, 0}, 1}, 1758 { &APFloat::IEEEdouble(), true, {0x8000000000000000ULL, 0}, 1}, 1759 { &APFloat::IEEEquad(), false, {0, 0}, 2}, 1760 { &APFloat::IEEEquad(), true, {0, 0x8000000000000000ULL}, 2}, 1761 { &APFloat::PPCDoubleDouble(), false, {0, 0}, 2}, 1762 { &APFloat::PPCDoubleDouble(), true, {0x8000000000000000ULL, 0}, 2}, 1763 { &APFloat::x87DoubleExtended(), false, {0, 0}, 2}, 1764 { &APFloat::x87DoubleExtended(), true, {0, 0x8000ULL}, 2}, 1765 }; 1766 const unsigned NumGetZeroTests = 12; 1767 for (unsigned i = 0; i < NumGetZeroTests; ++i) { 1768 APFloat test = APFloat::getZero(*GetZeroTest[i].semantics, 1769 GetZeroTest[i].sign); 1770 const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0"; 1771 APFloat expected = APFloat(*GetZeroTest[i].semantics, 1772 pattern); 1773 EXPECT_TRUE(test.isZero()); 1774 EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative()); 1775 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1776 for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) { 1777 EXPECT_EQ(GetZeroTest[i].bitPattern[j], 1778 test.bitcastToAPInt().getRawData()[j]); 1779 } 1780 } 1781 } 1782 1783 TEST(APFloatTest, copySign) { 1784 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual( 1785 APFloat::copySign(APFloat(42.0), APFloat(-1.0)))); 1786 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual( 1787 APFloat::copySign(APFloat(-42.0), APFloat(1.0)))); 1788 EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual( 1789 APFloat::copySign(APFloat(-42.0), APFloat(-1.0)))); 1790 EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual( 1791 APFloat::copySign(APFloat(42.0), APFloat(1.0)))); 1792 } 1793 1794 TEST(APFloatTest, convert) { 1795 bool losesInfo; 1796 APFloat test(APFloat::IEEEdouble(), "1.0"); 1797 test.convert(APFloat::IEEEsingle(), APFloat::rmNearestTiesToEven, &losesInfo); 1798 EXPECT_EQ(1.0f, test.convertToFloat()); 1799 EXPECT_FALSE(losesInfo); 1800 1801 test = APFloat(APFloat::x87DoubleExtended(), "0x1p-53"); 1802 test.add(APFloat(APFloat::x87DoubleExtended(), "1.0"), APFloat::rmNearestTiesToEven); 1803 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo); 1804 EXPECT_EQ(1.0, test.convertToDouble()); 1805 EXPECT_TRUE(losesInfo); 1806 1807 test = APFloat(APFloat::IEEEquad(), "0x1p-53"); 1808 test.add(APFloat(APFloat::IEEEquad(), "1.0"), APFloat::rmNearestTiesToEven); 1809 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo); 1810 EXPECT_EQ(1.0, test.convertToDouble()); 1811 EXPECT_TRUE(losesInfo); 1812 1813 test = APFloat(APFloat::x87DoubleExtended(), "0xf.fffffffp+28"); 1814 test.convert(APFloat::IEEEdouble(), APFloat::rmNearestTiesToEven, &losesInfo); 1815 EXPECT_EQ(4294967295.0, test.convertToDouble()); 1816 EXPECT_FALSE(losesInfo); 1817 1818 test = APFloat::getSNaN(APFloat::IEEEsingle()); 1819 APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended()); 1820 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven, 1821 &losesInfo); 1822 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN)); 1823 EXPECT_FALSE(losesInfo); 1824 1825 test = APFloat::getQNaN(APFloat::IEEEsingle()); 1826 APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended()); 1827 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven, 1828 &losesInfo); 1829 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN)); 1830 EXPECT_FALSE(losesInfo); 1831 1832 test = APFloat::getSNaN(APFloat::x87DoubleExtended()); 1833 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven, 1834 &losesInfo); 1835 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN)); 1836 EXPECT_FALSE(losesInfo); 1837 1838 test = APFloat::getQNaN(APFloat::x87DoubleExtended()); 1839 test.convert(APFloat::x87DoubleExtended(), APFloat::rmNearestTiesToEven, 1840 &losesInfo); 1841 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN)); 1842 EXPECT_FALSE(losesInfo); 1843 } 1844 1845 TEST(APFloatTest, PPCDoubleDouble) { 1846 APFloat test(APFloat::PPCDoubleDouble(), "1.0"); 1847 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]); 1848 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]); 1849 1850 // LDBL_MAX 1851 test = APFloat(APFloat::PPCDoubleDouble(), "1.79769313486231580793728971405301e+308"); 1852 EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]); 1853 EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]); 1854 1855 // LDBL_MIN 1856 test = APFloat(APFloat::PPCDoubleDouble(), "2.00416836000897277799610805135016e-292"); 1857 EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]); 1858 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]); 1859 1860 // PR30869 1861 { 1862 auto Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") + 1863 APFloat(APFloat::PPCDoubleDouble(), "1.0"); 1864 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics()); 1865 1866 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") - 1867 APFloat(APFloat::PPCDoubleDouble(), "1.0"); 1868 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics()); 1869 1870 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") * 1871 APFloat(APFloat::PPCDoubleDouble(), "1.0"); 1872 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics()); 1873 1874 Result = APFloat(APFloat::PPCDoubleDouble(), "1.0") / 1875 APFloat(APFloat::PPCDoubleDouble(), "1.0"); 1876 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics()); 1877 1878 int Exp; 1879 Result = frexp(APFloat(APFloat::PPCDoubleDouble(), "1.0"), Exp, 1880 APFloat::rmNearestTiesToEven); 1881 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics()); 1882 1883 Result = scalbn(APFloat(APFloat::PPCDoubleDouble(), "1.0"), 1, 1884 APFloat::rmNearestTiesToEven); 1885 EXPECT_EQ(&APFloat::PPCDoubleDouble(), &Result.getSemantics()); 1886 } 1887 } 1888 1889 TEST(APFloatTest, isNegative) { 1890 APFloat t(APFloat::IEEEsingle(), "0x1p+0"); 1891 EXPECT_FALSE(t.isNegative()); 1892 t = APFloat(APFloat::IEEEsingle(), "-0x1p+0"); 1893 EXPECT_TRUE(t.isNegative()); 1894 1895 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNegative()); 1896 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), true).isNegative()); 1897 1898 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNegative()); 1899 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), true).isNegative()); 1900 1901 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNegative()); 1902 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), true).isNegative()); 1903 1904 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNegative()); 1905 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isNegative()); 1906 } 1907 1908 TEST(APFloatTest, isNormal) { 1909 APFloat t(APFloat::IEEEsingle(), "0x1p+0"); 1910 EXPECT_TRUE(t.isNormal()); 1911 1912 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNormal()); 1913 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNormal()); 1914 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNormal()); 1915 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNormal()); 1916 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNormal()); 1917 } 1918 1919 TEST(APFloatTest, isFinite) { 1920 APFloat t(APFloat::IEEEsingle(), "0x1p+0"); 1921 EXPECT_TRUE(t.isFinite()); 1922 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFinite()); 1923 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle(), false).isFinite()); 1924 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFinite()); 1925 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFinite()); 1926 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFinite()); 1927 } 1928 1929 TEST(APFloatTest, isInfinity) { 1930 APFloat t(APFloat::IEEEsingle(), "0x1p+0"); 1931 EXPECT_FALSE(t.isInfinity()); 1932 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle(), false).isInfinity()); 1933 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isInfinity()); 1934 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isInfinity()); 1935 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isInfinity()); 1936 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isInfinity()); 1937 } 1938 1939 TEST(APFloatTest, isNaN) { 1940 APFloat t(APFloat::IEEEsingle(), "0x1p+0"); 1941 EXPECT_FALSE(t.isNaN()); 1942 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isNaN()); 1943 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isNaN()); 1944 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle(), false).isNaN()); 1945 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isNaN()); 1946 EXPECT_FALSE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isNaN()); 1947 } 1948 1949 TEST(APFloatTest, isFiniteNonZero) { 1950 // Test positive/negative normal value. 1951 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p+0").isFiniteNonZero()); 1952 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p+0").isFiniteNonZero()); 1953 1954 // Test positive/negative denormal value. 1955 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "0x1p-149").isFiniteNonZero()); 1956 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").isFiniteNonZero()); 1957 1958 // Test +/- Infinity. 1959 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), false).isFiniteNonZero()); 1960 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle(), true).isFiniteNonZero()); 1961 1962 // Test +/- Zero. 1963 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), false).isFiniteNonZero()); 1964 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle(), true).isFiniteNonZero()); 1965 1966 // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in 1967 // this instance. 1968 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), false).isFiniteNonZero()); 1969 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle(), true).isFiniteNonZero()); 1970 1971 // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in 1972 // this instance. 1973 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), false).isFiniteNonZero()); 1974 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle(), true).isFiniteNonZero()); 1975 } 1976 1977 TEST(APFloatTest, add) { 1978 // Test Special Cases against each other and normal values. 1979 1980 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false); 1981 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true); 1982 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false); 1983 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true); 1984 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false); 1985 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123"); 1986 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0"); 1987 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0"); 1988 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false); 1989 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true); 1990 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false); 1991 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true); 1992 APFloat PSmallestNormalized = 1993 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false); 1994 APFloat MSmallestNormalized = 1995 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true); 1996 1997 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact; 1998 1999 struct { 2000 APFloat x; 2001 APFloat y; 2002 const char *result; 2003 int status; 2004 int category; 2005 } SpecialCaseTests[] = { 2006 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2007 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2008 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 2009 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 2010 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2011 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2012 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2013 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2014 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2015 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2016 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2017 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2018 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2019 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2020 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2021 { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2022 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2023 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2024 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2025 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2026 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2027 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2028 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2029 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2030 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2031 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2032 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2033 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2034 { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2035 { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2036 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2037 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2038 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2039 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2040 { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2041 { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2042 { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2043 { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2044 { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2045 { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2046 { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2047 { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2048 { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2049 { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2050 { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2051 { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2052 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2053 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2054 { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2055 { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2056 { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2057 { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2058 { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2059 { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2060 { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2061 { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2062 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2063 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2064 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2065 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2066 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2067 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2068 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2069 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2070 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2071 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2072 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2073 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2074 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2075 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2076 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2077 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2078 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2079 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2080 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2081 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2082 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2083 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2084 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2085 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2086 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2087 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2088 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2089 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2090 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2091 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2092 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2093 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2094 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2095 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2096 { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal }, 2097 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2098 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2099 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2100 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2101 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2102 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2103 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2104 { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2105 { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2106 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2107 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2108 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2109 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2110 { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2111 { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal }, 2112 { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2113 { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2114 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2115 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2116 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2117 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2118 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2119 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2120 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2121 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2122 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2123 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2124 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2125 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2126 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2127 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2128 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2129 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2130 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2131 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2132 { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2133 { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2134 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2135 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2136 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2137 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2138 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2139 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2140 { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2141 { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2142 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2143 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2144 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2145 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2146 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2147 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2148 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2149 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2150 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2151 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2152 { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2153 { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2154 { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2155 { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2156 { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal }, 2157 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2158 { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2159 { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2160 { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2161 { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2162 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2163 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2164 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2165 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2166 { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2167 { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2168 { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2169 { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2170 { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2171 { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal }, 2172 { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2173 { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2174 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2175 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2176 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2177 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2178 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2179 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2180 { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2181 { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2182 { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2183 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2184 { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2185 { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2186 { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal }, 2187 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2188 { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2189 { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2190 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2191 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2192 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2193 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2194 { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2195 { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2196 { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2197 { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2198 { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2199 { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2200 { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2201 { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal } 2202 }; 2203 2204 for (size_t i = 0; i < array_lengthof(SpecialCaseTests); ++i) { 2205 APFloat x(SpecialCaseTests[i].x); 2206 APFloat y(SpecialCaseTests[i].y); 2207 APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven); 2208 2209 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result); 2210 2211 EXPECT_TRUE(result.bitwiseIsEqual(x)); 2212 EXPECT_EQ(SpecialCaseTests[i].status, (int)status); 2213 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory()); 2214 } 2215 } 2216 2217 TEST(APFloatTest, subtract) { 2218 // Test Special Cases against each other and normal values. 2219 2220 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false); 2221 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true); 2222 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false); 2223 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true); 2224 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false); 2225 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123"); 2226 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0"); 2227 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0"); 2228 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false); 2229 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true); 2230 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false); 2231 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true); 2232 APFloat PSmallestNormalized = 2233 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false); 2234 APFloat MSmallestNormalized = 2235 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true); 2236 2237 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact; 2238 2239 struct { 2240 APFloat x; 2241 APFloat y; 2242 const char *result; 2243 int status; 2244 int category; 2245 } SpecialCaseTests[] = { 2246 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2247 { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2248 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 2249 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 2250 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2251 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2252 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2253 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2254 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2255 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2256 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2257 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2258 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2259 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2260 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2261 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2262 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2263 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2264 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2265 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2266 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2267 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2268 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2269 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2270 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2271 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2272 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2273 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2274 { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2275 { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2276 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2277 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2278 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2279 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2280 { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2281 { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2282 { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2283 { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2284 { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2285 { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2286 { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2287 { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2288 { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2289 { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2290 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2291 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2292 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2293 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2294 { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2295 { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2296 { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2297 { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2298 { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2299 { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2300 { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2301 { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2302 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2303 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2304 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2305 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2306 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2307 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2308 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2309 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2310 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2311 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2312 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2313 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2314 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2315 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2316 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2317 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2318 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2319 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2320 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2321 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2322 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2323 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2324 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2325 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2326 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2327 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2328 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2329 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2330 { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2331 { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2332 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2333 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2334 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2335 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2336 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2337 { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal }, 2338 { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2339 { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2340 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2341 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2342 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2343 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2344 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2345 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2346 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2347 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2348 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2349 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2350 { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal }, 2351 { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2352 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2353 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2354 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2355 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2356 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2357 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2358 { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2359 { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2360 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2361 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2362 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2363 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2364 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2365 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2366 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2367 { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2368 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2369 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2370 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2371 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2372 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2373 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2374 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2375 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2376 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2377 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2378 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2379 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2380 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2381 { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2382 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2383 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2384 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2385 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2386 { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2387 { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2388 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2389 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2390 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2391 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2392 { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2393 { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2394 { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2395 { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2396 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2397 { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal }, 2398 { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2399 { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2400 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2401 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2402 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2403 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2404 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2405 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2406 { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2407 { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2408 { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2409 { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2410 { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal }, 2411 { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2412 { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2413 { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2414 { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2415 { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2416 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2417 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2418 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2419 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2420 { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2421 { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2422 { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2423 { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2424 { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2425 { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2426 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2427 { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal }, 2428 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2429 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2430 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2431 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2432 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2433 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2434 { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2435 { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2436 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2437 { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2438 { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2439 { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2440 { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }, 2441 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero } 2442 }; 2443 2444 for (size_t i = 0; i < array_lengthof(SpecialCaseTests); ++i) { 2445 APFloat x(SpecialCaseTests[i].x); 2446 APFloat y(SpecialCaseTests[i].y); 2447 APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven); 2448 2449 APFloat result(APFloat::IEEEsingle(), SpecialCaseTests[i].result); 2450 2451 EXPECT_TRUE(result.bitwiseIsEqual(x)); 2452 EXPECT_EQ(SpecialCaseTests[i].status, (int)status); 2453 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory()); 2454 } 2455 } 2456 2457 TEST(APFloatTest, multiply) { 2458 // Test Special Cases against each other and normal values. 2459 2460 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false); 2461 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true); 2462 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false); 2463 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true); 2464 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false); 2465 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123"); 2466 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0"); 2467 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0"); 2468 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false); 2469 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true); 2470 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false); 2471 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true); 2472 APFloat PSmallestNormalized = 2473 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false); 2474 APFloat MSmallestNormalized = 2475 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true); 2476 2477 APFloat MaxQuad(APFloat::IEEEquad(), 2478 "0x1.ffffffffffffffffffffffffffffp+16383"); 2479 APFloat MinQuad(APFloat::IEEEquad(), 2480 "0x0.0000000000000000000000000001p-16382"); 2481 APFloat NMinQuad(APFloat::IEEEquad(), 2482 "-0x0.0000000000000000000000000001p-16382"); 2483 2484 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact; 2485 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact; 2486 2487 struct { 2488 APFloat x; 2489 APFloat y; 2490 const char *result; 2491 int status; 2492 int category; 2493 APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven; 2494 } SpecialCaseTests[] = { 2495 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2496 { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2497 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2498 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2499 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2500 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2501 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2502 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2503 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2504 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2505 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2506 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2507 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2508 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2509 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2510 { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2511 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2512 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2513 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2514 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2515 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2516 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2517 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2518 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2519 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2520 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2521 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2522 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2523 { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2524 { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2525 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2526 { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2527 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2528 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2529 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2530 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2531 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2532 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2533 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2534 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2535 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2536 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2537 { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2538 { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2539 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2540 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2541 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2542 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2543 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2544 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2545 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2546 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2547 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2548 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2549 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2550 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2551 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2552 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2553 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2554 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2555 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2556 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2557 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2558 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2559 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2560 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2561 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2562 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2563 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2564 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2565 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2566 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2567 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2568 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2569 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2570 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2571 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2572 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2573 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2574 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2575 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2576 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2577 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2578 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2579 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2580 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2581 { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2582 { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2583 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2584 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2585 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2586 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2587 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2588 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2589 { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2590 { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2591 { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2592 { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2593 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2594 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2595 { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2596 { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2597 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2598 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2599 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2600 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2601 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2602 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2603 { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2604 { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2605 { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2606 { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2607 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2608 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2609 { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2610 { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2611 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2612 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2613 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2614 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2615 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2616 { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2617 { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2618 { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2619 { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2620 { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2621 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2622 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2623 { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2624 { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2625 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2626 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2627 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2628 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2629 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2630 { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2631 { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2632 { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2633 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2634 { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2635 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2636 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2637 { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2638 { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2639 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2640 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2641 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2642 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2643 { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2644 { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2645 { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2646 { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2647 { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2648 { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2649 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2650 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2651 { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2652 { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2653 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2654 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2655 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2656 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2657 { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2658 { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2659 { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2660 { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2661 { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2662 { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2663 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2664 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2665 { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2666 { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2667 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2668 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2669 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2670 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2671 { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2672 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2673 { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2674 { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2675 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2676 { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2677 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2678 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2679 { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2680 { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2681 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2682 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2683 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2684 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2685 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2686 { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2687 { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2688 { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2689 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2690 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2691 2692 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK, 2693 APFloat::fcNormal, APFloat::rmNearestTiesToEven}, 2694 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK, 2695 APFloat::fcNormal, APFloat::rmTowardPositive}, 2696 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK, 2697 APFloat::fcNormal, APFloat::rmTowardNegative}, 2698 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK, 2699 APFloat::fcNormal, APFloat::rmTowardZero}, 2700 {MaxQuad, MinQuad, "0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK, 2701 APFloat::fcNormal, APFloat::rmNearestTiesToAway}, 2702 2703 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK, 2704 APFloat::fcNormal, APFloat::rmNearestTiesToEven}, 2705 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK, 2706 APFloat::fcNormal, APFloat::rmTowardPositive}, 2707 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK, 2708 APFloat::fcNormal, APFloat::rmTowardNegative}, 2709 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK, 2710 APFloat::fcNormal, APFloat::rmTowardZero}, 2711 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp-111", APFloat::opOK, 2712 APFloat::fcNormal, APFloat::rmNearestTiesToAway}, 2713 2714 {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity, 2715 APFloat::rmNearestTiesToEven}, 2716 {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity, 2717 APFloat::rmTowardPositive}, 2718 {MaxQuad, MaxQuad, "0x1.ffffffffffffffffffffffffffffp+16383", 2719 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardNegative}, 2720 {MaxQuad, MaxQuad, "0x1.ffffffffffffffffffffffffffffp+16383", 2721 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardZero}, 2722 {MaxQuad, MaxQuad, "inf", OverflowStatus, APFloat::fcInfinity, 2723 APFloat::rmNearestTiesToAway}, 2724 2725 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero, 2726 APFloat::rmNearestTiesToEven}, 2727 {MinQuad, MinQuad, "0x0.0000000000000000000000000001p-16382", 2728 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardPositive}, 2729 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero, 2730 APFloat::rmTowardNegative}, 2731 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero, 2732 APFloat::rmTowardZero}, 2733 {MinQuad, MinQuad, "0", UnderflowStatus, APFloat::fcZero, 2734 APFloat::rmNearestTiesToAway}, 2735 2736 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero, 2737 APFloat::rmNearestTiesToEven}, 2738 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero, 2739 APFloat::rmTowardPositive}, 2740 {MinQuad, NMinQuad, "-0x0.0000000000000000000000000001p-16382", 2741 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardNegative}, 2742 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero, 2743 APFloat::rmTowardZero}, 2744 {MinQuad, NMinQuad, "-0", UnderflowStatus, APFloat::fcZero, 2745 APFloat::rmNearestTiesToAway}, 2746 }; 2747 2748 for (size_t i = 0; i < array_lengthof(SpecialCaseTests); ++i) { 2749 APFloat x(SpecialCaseTests[i].x); 2750 APFloat y(SpecialCaseTests[i].y); 2751 APFloat::opStatus status = x.multiply(y, SpecialCaseTests[i].roundingMode); 2752 2753 APFloat result(x.getSemantics(), SpecialCaseTests[i].result); 2754 2755 EXPECT_TRUE(result.bitwiseIsEqual(x)); 2756 EXPECT_EQ(SpecialCaseTests[i].status, (int)status); 2757 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory()); 2758 } 2759 } 2760 2761 TEST(APFloatTest, divide) { 2762 // Test Special Cases against each other and normal values. 2763 2764 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false); 2765 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true); 2766 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false); 2767 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true); 2768 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false); 2769 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123"); 2770 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0"); 2771 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0"); 2772 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false); 2773 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true); 2774 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false); 2775 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true); 2776 APFloat PSmallestNormalized = 2777 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false); 2778 APFloat MSmallestNormalized = 2779 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true); 2780 2781 APFloat MaxQuad(APFloat::IEEEquad(), 2782 "0x1.ffffffffffffffffffffffffffffp+16383"); 2783 APFloat MinQuad(APFloat::IEEEquad(), 2784 "0x0.0000000000000000000000000001p-16382"); 2785 APFloat NMinQuad(APFloat::IEEEquad(), 2786 "-0x0.0000000000000000000000000001p-16382"); 2787 2788 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact; 2789 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact; 2790 2791 struct { 2792 APFloat x; 2793 APFloat y; 2794 const char *result; 2795 int status; 2796 int category; 2797 APFloat::roundingMode roundingMode = APFloat::rmNearestTiesToEven; 2798 } SpecialCaseTests[] = { 2799 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2800 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2801 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 2802 { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2803 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2804 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2805 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2806 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2807 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2808 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2809 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2810 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2811 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2812 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2813 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2814 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2815 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2816 { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 2817 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2818 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2819 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2820 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2821 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2822 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2823 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2824 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2825 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2826 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2827 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2828 { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2829 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2830 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2831 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2832 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2833 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2834 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2835 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2836 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2837 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2838 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2839 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2840 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2841 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2842 { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2843 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2844 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2845 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2846 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2847 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2848 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2849 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2850 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2851 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2852 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2853 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2854 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2855 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2856 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2857 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2858 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2859 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2860 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2861 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2862 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2863 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2864 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2865 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2866 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2867 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2868 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2869 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2870 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2871 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2872 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2873 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2874 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2875 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2876 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2877 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2878 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2879 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2880 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2881 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2882 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2883 { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2884 { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2885 { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2886 { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2887 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2888 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2889 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2890 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2891 { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal }, 2892 { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal }, 2893 { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2894 { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2895 { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal }, 2896 { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal }, 2897 { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2898 { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2899 { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2900 { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2901 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2902 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2903 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2904 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2905 { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal }, 2906 { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal }, 2907 { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2908 { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2909 { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal }, 2910 { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal }, 2911 { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2912 { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2913 { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2914 { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2915 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2916 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2917 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2918 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2919 { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2920 { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2921 { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2922 { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2923 { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity }, 2924 { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity }, 2925 { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2926 { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2927 { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2928 { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2929 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2930 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2931 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2932 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2933 { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2934 { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2935 { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2936 { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2937 { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity }, 2938 { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity }, 2939 { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2940 { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2941 { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2942 { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2943 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2944 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2945 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2946 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2947 { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2948 { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2949 { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2950 { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2951 { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal }, 2952 { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal }, 2953 { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2954 { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2955 { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2956 { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2957 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2958 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2959 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2960 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2961 { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2962 { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2963 { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2964 { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2965 { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal }, 2966 { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal }, 2967 { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2968 { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2969 { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2970 { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2971 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2972 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2973 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2974 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2975 { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2976 { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2977 { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal }, 2978 { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal }, 2979 { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2980 { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2981 { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2982 { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2983 { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2984 { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2985 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2986 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 2987 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2988 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2989 { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2990 { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2991 { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal }, 2992 { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal }, 2993 { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2994 { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2995 2996 {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity, 2997 APFloat::rmNearestTiesToEven}, 2998 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp+16383", 2999 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardPositive}, 3000 {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity, 3001 APFloat::rmTowardNegative}, 3002 {MaxQuad, NMinQuad, "-0x1.ffffffffffffffffffffffffffffp+16383", 3003 APFloat::opInexact, APFloat::fcNormal, APFloat::rmTowardZero}, 3004 {MaxQuad, NMinQuad, "-inf", OverflowStatus, APFloat::fcInfinity, 3005 APFloat::rmNearestTiesToAway}, 3006 3007 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero, 3008 APFloat::rmNearestTiesToEven}, 3009 {MinQuad, MaxQuad, "0x0.0000000000000000000000000001p-16382", 3010 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardPositive}, 3011 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero, 3012 APFloat::rmTowardNegative}, 3013 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero, 3014 APFloat::rmTowardZero}, 3015 {MinQuad, MaxQuad, "0", UnderflowStatus, APFloat::fcZero, 3016 APFloat::rmNearestTiesToAway}, 3017 3018 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero, 3019 APFloat::rmNearestTiesToEven}, 3020 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero, 3021 APFloat::rmTowardPositive}, 3022 {NMinQuad, MaxQuad, "-0x0.0000000000000000000000000001p-16382", 3023 UnderflowStatus, APFloat::fcNormal, APFloat::rmTowardNegative}, 3024 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero, 3025 APFloat::rmTowardZero}, 3026 {NMinQuad, MaxQuad, "-0", UnderflowStatus, APFloat::fcZero, 3027 APFloat::rmNearestTiesToAway}, 3028 }; 3029 3030 for (size_t i = 0; i < array_lengthof(SpecialCaseTests); ++i) { 3031 APFloat x(SpecialCaseTests[i].x); 3032 APFloat y(SpecialCaseTests[i].y); 3033 APFloat::opStatus status = x.divide(y, SpecialCaseTests[i].roundingMode); 3034 3035 APFloat result(x.getSemantics(), SpecialCaseTests[i].result); 3036 3037 EXPECT_TRUE(result.bitwiseIsEqual(x)); 3038 EXPECT_EQ(SpecialCaseTests[i].status, (int)status); 3039 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory()); 3040 } 3041 } 3042 3043 TEST(APFloatTest, operatorOverloads) { 3044 // This is mostly testing that these operator overloads compile. 3045 APFloat One = APFloat(APFloat::IEEEsingle(), "0x1p+0"); 3046 APFloat Two = APFloat(APFloat::IEEEsingle(), "0x2p+0"); 3047 EXPECT_TRUE(Two.bitwiseIsEqual(One + One)); 3048 EXPECT_TRUE(One.bitwiseIsEqual(Two - One)); 3049 EXPECT_TRUE(Two.bitwiseIsEqual(One * Two)); 3050 EXPECT_TRUE(One.bitwiseIsEqual(Two / Two)); 3051 } 3052 3053 TEST(APFloatTest, Comparisons) { 3054 enum {MNan, MInf, MBig, MOne, MZer, PZer, POne, PBig, PInf, PNan, NumVals}; 3055 APFloat Vals[NumVals] = { 3056 APFloat::getNaN(APFloat::IEEEsingle(), true), 3057 APFloat::getInf(APFloat::IEEEsingle(), true), 3058 APFloat::getLargest(APFloat::IEEEsingle(), true), 3059 APFloat(APFloat::IEEEsingle(), "-0x1p+0"), 3060 APFloat::getZero(APFloat::IEEEsingle(), true), 3061 APFloat::getZero(APFloat::IEEEsingle(), false), 3062 APFloat(APFloat::IEEEsingle(), "0x1p+0"), 3063 APFloat::getLargest(APFloat::IEEEsingle(), false), 3064 APFloat::getInf(APFloat::IEEEsingle(), false), 3065 APFloat::getNaN(APFloat::IEEEsingle(), false), 3066 }; 3067 using Relation = void (*)(const APFloat &, const APFloat &); 3068 Relation LT = [](const APFloat &LHS, const APFloat &RHS) { 3069 EXPECT_FALSE(LHS == RHS); 3070 EXPECT_TRUE(LHS != RHS); 3071 EXPECT_TRUE(LHS < RHS); 3072 EXPECT_FALSE(LHS > RHS); 3073 EXPECT_TRUE(LHS <= RHS); 3074 EXPECT_FALSE(LHS >= RHS); 3075 }; 3076 Relation EQ = [](const APFloat &LHS, const APFloat &RHS) { 3077 EXPECT_TRUE(LHS == RHS); 3078 EXPECT_FALSE(LHS != RHS); 3079 EXPECT_FALSE(LHS < RHS); 3080 EXPECT_FALSE(LHS > RHS); 3081 EXPECT_TRUE(LHS <= RHS); 3082 EXPECT_TRUE(LHS >= RHS); 3083 }; 3084 Relation GT = [](const APFloat &LHS, const APFloat &RHS) { 3085 EXPECT_FALSE(LHS == RHS); 3086 EXPECT_TRUE(LHS != RHS); 3087 EXPECT_FALSE(LHS < RHS); 3088 EXPECT_TRUE(LHS > RHS); 3089 EXPECT_FALSE(LHS <= RHS); 3090 EXPECT_TRUE(LHS >= RHS); 3091 }; 3092 Relation UN = [](const APFloat &LHS, const APFloat &RHS) { 3093 EXPECT_FALSE(LHS == RHS); 3094 EXPECT_TRUE(LHS != RHS); 3095 EXPECT_FALSE(LHS < RHS); 3096 EXPECT_FALSE(LHS > RHS); 3097 EXPECT_FALSE(LHS <= RHS); 3098 EXPECT_FALSE(LHS >= RHS); 3099 }; 3100 Relation Relations[NumVals][NumVals] = { 3101 // -N -I -B -1 -0 +0 +1 +B +I +N 3102 /* MNan */ {UN, UN, UN, UN, UN, UN, UN, UN, UN, UN}, 3103 /* MInf */ {UN, EQ, LT, LT, LT, LT, LT, LT, LT, UN}, 3104 /* MBig */ {UN, GT, EQ, LT, LT, LT, LT, LT, LT, UN}, 3105 /* MOne */ {UN, GT, GT, EQ, LT, LT, LT, LT, LT, UN}, 3106 /* MZer */ {UN, GT, GT, GT, EQ, EQ, LT, LT, LT, UN}, 3107 /* PZer */ {UN, GT, GT, GT, EQ, EQ, LT, LT, LT, UN}, 3108 /* POne */ {UN, GT, GT, GT, GT, GT, EQ, LT, LT, UN}, 3109 /* PBig */ {UN, GT, GT, GT, GT, GT, GT, EQ, LT, UN}, 3110 /* PInf */ {UN, GT, GT, GT, GT, GT, GT, GT, EQ, UN}, 3111 /* PNan */ {UN, UN, UN, UN, UN, UN, UN, UN, UN, UN}, 3112 }; 3113 for (unsigned I = 0; I < NumVals; ++I) 3114 for (unsigned J = 0; J < NumVals; ++J) 3115 Relations[I][J](Vals[I], Vals[J]); 3116 } 3117 3118 TEST(APFloatTest, abs) { 3119 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false); 3120 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true); 3121 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false); 3122 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true); 3123 APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle(), false); 3124 APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true); 3125 APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false); 3126 APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle(), true); 3127 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0"); 3128 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0"); 3129 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false); 3130 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true); 3131 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false); 3132 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true); 3133 APFloat PSmallestNormalized = 3134 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false); 3135 APFloat MSmallestNormalized = 3136 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true); 3137 3138 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(PInf))); 3139 EXPECT_TRUE(PInf.bitwiseIsEqual(abs(MInf))); 3140 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(PZero))); 3141 EXPECT_TRUE(PZero.bitwiseIsEqual(abs(MZero))); 3142 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(PQNaN))); 3143 EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(MQNaN))); 3144 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(PSNaN))); 3145 EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(MSNaN))); 3146 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(PNormalValue))); 3147 EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(MNormalValue))); 3148 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(PLargestValue))); 3149 EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(MLargestValue))); 3150 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(PSmallestValue))); 3151 EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(MSmallestValue))); 3152 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(PSmallestNormalized))); 3153 EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized))); 3154 } 3155 3156 TEST(APFloatTest, neg) { 3157 APFloat One = APFloat(APFloat::IEEEsingle(), "1.0"); 3158 APFloat NegOne = APFloat(APFloat::IEEEsingle(), "-1.0"); 3159 APFloat Zero = APFloat::getZero(APFloat::IEEEsingle(), false); 3160 APFloat NegZero = APFloat::getZero(APFloat::IEEEsingle(), true); 3161 APFloat Inf = APFloat::getInf(APFloat::IEEEsingle(), false); 3162 APFloat NegInf = APFloat::getInf(APFloat::IEEEsingle(), true); 3163 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false); 3164 APFloat NegQNaN = APFloat::getNaN(APFloat::IEEEsingle(), true); 3165 3166 EXPECT_TRUE(NegOne.bitwiseIsEqual(neg(One))); 3167 EXPECT_TRUE(One.bitwiseIsEqual(neg(NegOne))); 3168 EXPECT_TRUE(NegZero.bitwiseIsEqual(neg(Zero))); 3169 EXPECT_TRUE(Zero.bitwiseIsEqual(neg(NegZero))); 3170 EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf))); 3171 EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf))); 3172 EXPECT_TRUE(NegInf.bitwiseIsEqual(neg(Inf))); 3173 EXPECT_TRUE(Inf.bitwiseIsEqual(neg(NegInf))); 3174 EXPECT_TRUE(NegQNaN.bitwiseIsEqual(neg(QNaN))); 3175 EXPECT_TRUE(QNaN.bitwiseIsEqual(neg(NegQNaN))); 3176 3177 EXPECT_TRUE(NegOne.bitwiseIsEqual(-One)); 3178 EXPECT_TRUE(One.bitwiseIsEqual(-NegOne)); 3179 EXPECT_TRUE(NegZero.bitwiseIsEqual(-Zero)); 3180 EXPECT_TRUE(Zero.bitwiseIsEqual(-NegZero)); 3181 EXPECT_TRUE(NegInf.bitwiseIsEqual(-Inf)); 3182 EXPECT_TRUE(Inf.bitwiseIsEqual(-NegInf)); 3183 EXPECT_TRUE(NegInf.bitwiseIsEqual(-Inf)); 3184 EXPECT_TRUE(Inf.bitwiseIsEqual(-NegInf)); 3185 EXPECT_TRUE(NegQNaN.bitwiseIsEqual(-QNaN)); 3186 EXPECT_TRUE(QNaN.bitwiseIsEqual(-NegQNaN)); 3187 } 3188 3189 TEST(APFloatTest, ilogb) { 3190 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), false))); 3191 EXPECT_EQ(-1074, ilogb(APFloat::getSmallest(APFloat::IEEEdouble(), true))); 3192 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1024"))); 3193 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023"))); 3194 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023"))); 3195 EXPECT_EQ(-51, ilogb(APFloat(APFloat::IEEEdouble(), "0x1p-51"))); 3196 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1023"))); 3197 EXPECT_EQ(-2, ilogb(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1"))); 3198 EXPECT_EQ(-1023, ilogb(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1023"))); 3199 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), false))); 3200 EXPECT_EQ(1023, ilogb(APFloat::getLargest(APFloat::IEEEdouble(), true))); 3201 3202 3203 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+0"))); 3204 EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle(), "-0x1p+0"))); 3205 EXPECT_EQ(42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p+42"))); 3206 EXPECT_EQ(-42, ilogb(APFloat(APFloat::IEEEsingle(), "0x1p-42"))); 3207 3208 EXPECT_EQ(APFloat::IEK_Inf, 3209 ilogb(APFloat::getInf(APFloat::IEEEsingle(), false))); 3210 EXPECT_EQ(APFloat::IEK_Inf, 3211 ilogb(APFloat::getInf(APFloat::IEEEsingle(), true))); 3212 EXPECT_EQ(APFloat::IEK_Zero, 3213 ilogb(APFloat::getZero(APFloat::IEEEsingle(), false))); 3214 EXPECT_EQ(APFloat::IEK_Zero, 3215 ilogb(APFloat::getZero(APFloat::IEEEsingle(), true))); 3216 EXPECT_EQ(APFloat::IEK_NaN, 3217 ilogb(APFloat::getNaN(APFloat::IEEEsingle(), false))); 3218 EXPECT_EQ(APFloat::IEK_NaN, 3219 ilogb(APFloat::getSNaN(APFloat::IEEEsingle(), false))); 3220 3221 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), false))); 3222 EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle(), true))); 3223 3224 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), false))); 3225 EXPECT_EQ(-149, ilogb(APFloat::getSmallest(APFloat::IEEEsingle(), true))); 3226 EXPECT_EQ(-126, 3227 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false))); 3228 EXPECT_EQ(-126, 3229 ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true))); 3230 } 3231 3232 TEST(APFloatTest, scalbn) { 3233 3234 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven; 3235 EXPECT_TRUE( 3236 APFloat(APFloat::IEEEsingle(), "0x1p+0") 3237 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 0, RM))); 3238 EXPECT_TRUE( 3239 APFloat(APFloat::IEEEsingle(), "0x1p+42") 3240 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 42, RM))); 3241 EXPECT_TRUE( 3242 APFloat(APFloat::IEEEsingle(), "0x1p-42") 3243 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), -42, RM))); 3244 3245 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false); 3246 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true); 3247 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false); 3248 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true); 3249 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle(), false); 3250 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle(), true); 3251 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle(), false); 3252 3253 EXPECT_TRUE(PInf.bitwiseIsEqual(scalbn(PInf, 0, RM))); 3254 EXPECT_TRUE(MInf.bitwiseIsEqual(scalbn(MInf, 0, RM))); 3255 EXPECT_TRUE(PZero.bitwiseIsEqual(scalbn(PZero, 0, RM))); 3256 EXPECT_TRUE(MZero.bitwiseIsEqual(scalbn(MZero, 0, RM))); 3257 EXPECT_TRUE(QPNaN.bitwiseIsEqual(scalbn(QPNaN, 0, RM))); 3258 EXPECT_TRUE(QMNaN.bitwiseIsEqual(scalbn(QMNaN, 0, RM))); 3259 EXPECT_FALSE(scalbn(SNaN, 0, RM).isSignaling()); 3260 3261 APFloat ScalbnSNaN = scalbn(SNaN, 1, RM); 3262 EXPECT_TRUE(ScalbnSNaN.isNaN() && !ScalbnSNaN.isSignaling()); 3263 3264 // Make sure highest bit of payload is preserved. 3265 const APInt Payload(64, (UINT64_C(1) << 50) | 3266 (UINT64_C(1) << 49) | 3267 (UINT64_C(1234) << 32) | 3268 1); 3269 3270 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false, 3271 &Payload); 3272 APFloat QuietPayload = scalbn(SNaNWithPayload, 1, RM); 3273 EXPECT_TRUE(QuietPayload.isNaN() && !QuietPayload.isSignaling()); 3274 EXPECT_EQ(Payload, QuietPayload.bitcastToAPInt().getLoBits(51)); 3275 3276 EXPECT_TRUE(PInf.bitwiseIsEqual( 3277 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+0"), 128, RM))); 3278 EXPECT_TRUE(MInf.bitwiseIsEqual( 3279 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p+0"), 128, RM))); 3280 EXPECT_TRUE(PInf.bitwiseIsEqual( 3281 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p+127"), 1, RM))); 3282 EXPECT_TRUE(PZero.bitwiseIsEqual( 3283 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-127"), -127, RM))); 3284 EXPECT_TRUE(MZero.bitwiseIsEqual( 3285 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -127, RM))); 3286 EXPECT_TRUE(APFloat(APFloat::IEEEsingle(), "-0x1p-149").bitwiseIsEqual( 3287 scalbn(APFloat(APFloat::IEEEsingle(), "-0x1p-127"), -22, RM))); 3288 EXPECT_TRUE(PZero.bitwiseIsEqual( 3289 scalbn(APFloat(APFloat::IEEEsingle(), "0x1p-126"), -24, RM))); 3290 3291 3292 APFloat SmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), false); 3293 APFloat NegSmallestF64 = APFloat::getSmallest(APFloat::IEEEdouble(), true); 3294 3295 APFloat LargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), false); 3296 APFloat NegLargestF64 = APFloat::getLargest(APFloat::IEEEdouble(), true); 3297 3298 APFloat SmallestNormalizedF64 3299 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false); 3300 APFloat NegSmallestNormalizedF64 3301 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true); 3302 3303 APFloat LargestDenormalF64(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023"); 3304 APFloat NegLargestDenormalF64(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023"); 3305 3306 3307 EXPECT_TRUE(SmallestF64.bitwiseIsEqual( 3308 scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-1074"), 0, RM))); 3309 EXPECT_TRUE(NegSmallestF64.bitwiseIsEqual( 3310 scalbn(APFloat(APFloat::IEEEdouble(), "-0x1p-1074"), 0, RM))); 3311 3312 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023") 3313 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM))); 3314 3315 EXPECT_TRUE(scalbn(SmallestF64, -2097, RM).isPosZero()); 3316 EXPECT_TRUE(scalbn(SmallestF64, -2098, RM).isPosZero()); 3317 EXPECT_TRUE(scalbn(SmallestF64, -2099, RM).isPosZero()); 3318 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1022") 3319 .bitwiseIsEqual(scalbn(SmallestF64, 2096, RM))); 3320 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+1023") 3321 .bitwiseIsEqual(scalbn(SmallestF64, 2097, RM))); 3322 EXPECT_TRUE(scalbn(SmallestF64, 2098, RM).isInfinity()); 3323 EXPECT_TRUE(scalbn(SmallestF64, 2099, RM).isInfinity()); 3324 3325 // Test for integer overflows when adding to exponent. 3326 EXPECT_TRUE(scalbn(SmallestF64, -INT_MAX, RM).isPosZero()); 3327 EXPECT_TRUE(scalbn(LargestF64, INT_MAX, RM).isInfinity()); 3328 3329 EXPECT_TRUE(LargestDenormalF64 3330 .bitwiseIsEqual(scalbn(LargestDenormalF64, 0, RM))); 3331 EXPECT_TRUE(NegLargestDenormalF64 3332 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 0, RM))); 3333 3334 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1022") 3335 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1, RM))); 3336 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1021") 3337 .bitwiseIsEqual(scalbn(NegLargestDenormalF64, 2, RM))); 3338 3339 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1") 3340 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1024, RM))); 3341 EXPECT_TRUE(scalbn(LargestDenormalF64, -1023, RM).isPosZero()); 3342 EXPECT_TRUE(scalbn(LargestDenormalF64, -1024, RM).isPosZero()); 3343 EXPECT_TRUE(scalbn(LargestDenormalF64, -2048, RM).isPosZero()); 3344 EXPECT_TRUE(scalbn(LargestDenormalF64, 2047, RM).isInfinity()); 3345 EXPECT_TRUE(scalbn(LargestDenormalF64, 2098, RM).isInfinity()); 3346 EXPECT_TRUE(scalbn(LargestDenormalF64, 2099, RM).isInfinity()); 3347 3348 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-2") 3349 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1021, RM))); 3350 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1") 3351 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1022, RM))); 3352 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+0") 3353 .bitwiseIsEqual(scalbn(LargestDenormalF64, 1023, RM))); 3354 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep+1023") 3355 .bitwiseIsEqual(scalbn(LargestDenormalF64, 2046, RM))); 3356 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p+974") 3357 .bitwiseIsEqual(scalbn(SmallestF64, 2048, RM))); 3358 3359 APFloat RandomDenormalF64(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51"); 3360 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-972") 3361 .bitwiseIsEqual(scalbn(RandomDenormalF64, -1023, RM))); 3362 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1") 3363 .bitwiseIsEqual(scalbn(RandomDenormalF64, -52, RM))); 3364 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-2") 3365 .bitwiseIsEqual(scalbn(RandomDenormalF64, -53, RM))); 3366 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+0") 3367 .bitwiseIsEqual(scalbn(RandomDenormalF64, -51, RM))); 3368 3369 EXPECT_TRUE(scalbn(RandomDenormalF64, -2097, RM).isPosZero()); 3370 EXPECT_TRUE(scalbn(RandomDenormalF64, -2090, RM).isPosZero()); 3371 3372 3373 EXPECT_TRUE( 3374 APFloat(APFloat::IEEEdouble(), "-0x1p-1073") 3375 .bitwiseIsEqual(scalbn(NegLargestF64, -2097, RM))); 3376 3377 EXPECT_TRUE( 3378 APFloat(APFloat::IEEEdouble(), "-0x1p-1024") 3379 .bitwiseIsEqual(scalbn(NegLargestF64, -2048, RM))); 3380 3381 EXPECT_TRUE( 3382 APFloat(APFloat::IEEEdouble(), "0x1p-1073") 3383 .bitwiseIsEqual(scalbn(LargestF64, -2097, RM))); 3384 3385 EXPECT_TRUE( 3386 APFloat(APFloat::IEEEdouble(), "0x1p-1074") 3387 .bitwiseIsEqual(scalbn(LargestF64, -2098, RM))); 3388 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1074") 3389 .bitwiseIsEqual(scalbn(NegLargestF64, -2098, RM))); 3390 EXPECT_TRUE(scalbn(NegLargestF64, -2099, RM).isNegZero()); 3391 EXPECT_TRUE(scalbn(LargestF64, 1, RM).isInfinity()); 3392 3393 3394 EXPECT_TRUE( 3395 APFloat(APFloat::IEEEdouble(), "0x1p+0") 3396 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p+52"), -52, RM))); 3397 3398 EXPECT_TRUE( 3399 APFloat(APFloat::IEEEdouble(), "0x1p-103") 3400 .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEdouble(), "0x1p-51"), -52, RM))); 3401 } 3402 3403 TEST(APFloatTest, frexp) { 3404 const APFloat::roundingMode RM = APFloat::rmNearestTiesToEven; 3405 3406 APFloat PZero = APFloat::getZero(APFloat::IEEEdouble(), false); 3407 APFloat MZero = APFloat::getZero(APFloat::IEEEdouble(), true); 3408 APFloat One(1.0); 3409 APFloat MOne(-1.0); 3410 APFloat Two(2.0); 3411 APFloat MTwo(-2.0); 3412 3413 APFloat LargestDenormal(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1023"); 3414 APFloat NegLargestDenormal(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1023"); 3415 3416 APFloat Smallest = APFloat::getSmallest(APFloat::IEEEdouble(), false); 3417 APFloat NegSmallest = APFloat::getSmallest(APFloat::IEEEdouble(), true); 3418 3419 APFloat Largest = APFloat::getLargest(APFloat::IEEEdouble(), false); 3420 APFloat NegLargest = APFloat::getLargest(APFloat::IEEEdouble(), true); 3421 3422 APFloat PInf = APFloat::getInf(APFloat::IEEEdouble(), false); 3423 APFloat MInf = APFloat::getInf(APFloat::IEEEdouble(), true); 3424 3425 APFloat QPNaN = APFloat::getNaN(APFloat::IEEEdouble(), false); 3426 APFloat QMNaN = APFloat::getNaN(APFloat::IEEEdouble(), true); 3427 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEdouble(), false); 3428 3429 // Make sure highest bit of payload is preserved. 3430 const APInt Payload(64, (UINT64_C(1) << 50) | 3431 (UINT64_C(1) << 49) | 3432 (UINT64_C(1234) << 32) | 3433 1); 3434 3435 APFloat SNaNWithPayload = APFloat::getSNaN(APFloat::IEEEdouble(), false, 3436 &Payload); 3437 3438 APFloat SmallestNormalized 3439 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), false); 3440 APFloat NegSmallestNormalized 3441 = APFloat::getSmallestNormalized(APFloat::IEEEdouble(), true); 3442 3443 int Exp; 3444 APFloat Frac(APFloat::IEEEdouble()); 3445 3446 3447 Frac = frexp(PZero, Exp, RM); 3448 EXPECT_EQ(0, Exp); 3449 EXPECT_TRUE(Frac.isPosZero()); 3450 3451 Frac = frexp(MZero, Exp, RM); 3452 EXPECT_EQ(0, Exp); 3453 EXPECT_TRUE(Frac.isNegZero()); 3454 3455 3456 Frac = frexp(One, Exp, RM); 3457 EXPECT_EQ(1, Exp); 3458 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac)); 3459 3460 Frac = frexp(MOne, Exp, RM); 3461 EXPECT_EQ(1, Exp); 3462 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac)); 3463 3464 Frac = frexp(LargestDenormal, Exp, RM); 3465 EXPECT_EQ(-1022, Exp); 3466 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.ffffffffffffep-1").bitwiseIsEqual(Frac)); 3467 3468 Frac = frexp(NegLargestDenormal, Exp, RM); 3469 EXPECT_EQ(-1022, Exp); 3470 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.ffffffffffffep-1").bitwiseIsEqual(Frac)); 3471 3472 3473 Frac = frexp(Smallest, Exp, RM); 3474 EXPECT_EQ(-1073, Exp); 3475 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac)); 3476 3477 Frac = frexp(NegSmallest, Exp, RM); 3478 EXPECT_EQ(-1073, Exp); 3479 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1p-1").bitwiseIsEqual(Frac)); 3480 3481 3482 Frac = frexp(Largest, Exp, RM); 3483 EXPECT_EQ(1024, Exp); 3484 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffffffffffffp-1").bitwiseIsEqual(Frac)); 3485 3486 Frac = frexp(NegLargest, Exp, RM); 3487 EXPECT_EQ(1024, Exp); 3488 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "-0x1.fffffffffffffp-1").bitwiseIsEqual(Frac)); 3489 3490 3491 Frac = frexp(PInf, Exp, RM); 3492 EXPECT_EQ(INT_MAX, Exp); 3493 EXPECT_TRUE(Frac.isInfinity() && !Frac.isNegative()); 3494 3495 Frac = frexp(MInf, Exp, RM); 3496 EXPECT_EQ(INT_MAX, Exp); 3497 EXPECT_TRUE(Frac.isInfinity() && Frac.isNegative()); 3498 3499 Frac = frexp(QPNaN, Exp, RM); 3500 EXPECT_EQ(INT_MIN, Exp); 3501 EXPECT_TRUE(Frac.isNaN()); 3502 3503 Frac = frexp(QMNaN, Exp, RM); 3504 EXPECT_EQ(INT_MIN, Exp); 3505 EXPECT_TRUE(Frac.isNaN()); 3506 3507 Frac = frexp(SNaN, Exp, RM); 3508 EXPECT_EQ(INT_MIN, Exp); 3509 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling()); 3510 3511 Frac = frexp(SNaNWithPayload, Exp, RM); 3512 EXPECT_EQ(INT_MIN, Exp); 3513 EXPECT_TRUE(Frac.isNaN() && !Frac.isSignaling()); 3514 EXPECT_EQ(Payload, Frac.bitcastToAPInt().getLoBits(51)); 3515 3516 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x0.ffffp-1"), Exp, RM); 3517 EXPECT_EQ(-1, Exp); 3518 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.fffep-1").bitwiseIsEqual(Frac)); 3519 3520 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1p-51"), Exp, RM); 3521 EXPECT_EQ(-50, Exp); 3522 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1p-1").bitwiseIsEqual(Frac)); 3523 3524 Frac = frexp(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp+51"), Exp, RM); 3525 EXPECT_EQ(52, Exp); 3526 EXPECT_TRUE(APFloat(APFloat::IEEEdouble(), "0x1.c60f120d9f87cp-1").bitwiseIsEqual(Frac)); 3527 } 3528 3529 TEST(APFloatTest, mod) { 3530 { 3531 APFloat f1(APFloat::IEEEdouble(), "1.5"); 3532 APFloat f2(APFloat::IEEEdouble(), "1.0"); 3533 APFloat expected(APFloat::IEEEdouble(), "0.5"); 3534 EXPECT_EQ(f1.mod(f2), APFloat::opOK); 3535 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 3536 } 3537 { 3538 APFloat f1(APFloat::IEEEdouble(), "0.5"); 3539 APFloat f2(APFloat::IEEEdouble(), "1.0"); 3540 APFloat expected(APFloat::IEEEdouble(), "0.5"); 3541 EXPECT_EQ(f1.mod(f2), APFloat::opOK); 3542 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 3543 } 3544 { 3545 APFloat f1(APFloat::IEEEdouble(), "0x1.3333333333333p-2"); // 0.3 3546 APFloat f2(APFloat::IEEEdouble(), "0x1.47ae147ae147bp-7"); // 0.01 3547 APFloat expected(APFloat::IEEEdouble(), 3548 "0x1.47ae147ae1471p-7"); // 0.009999999999999983 3549 EXPECT_EQ(f1.mod(f2), APFloat::opOK); 3550 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 3551 } 3552 { 3553 APFloat f1(APFloat::IEEEdouble(), "0x1p64"); // 1.8446744073709552e19 3554 APFloat f2(APFloat::IEEEdouble(), "1.5"); 3555 APFloat expected(APFloat::IEEEdouble(), "1.0"); 3556 EXPECT_EQ(f1.mod(f2), APFloat::opOK); 3557 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 3558 } 3559 { 3560 APFloat f1(APFloat::IEEEdouble(), "0x1p1000"); 3561 APFloat f2(APFloat::IEEEdouble(), "0x1p-1000"); 3562 APFloat expected(APFloat::IEEEdouble(), "0.0"); 3563 EXPECT_EQ(f1.mod(f2), APFloat::opOK); 3564 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 3565 } 3566 { 3567 APFloat f1(APFloat::IEEEdouble(), "0.0"); 3568 APFloat f2(APFloat::IEEEdouble(), "1.0"); 3569 APFloat expected(APFloat::IEEEdouble(), "0.0"); 3570 EXPECT_EQ(f1.mod(f2), APFloat::opOK); 3571 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 3572 } 3573 { 3574 APFloat f1(APFloat::IEEEdouble(), "1.0"); 3575 APFloat f2(APFloat::IEEEdouble(), "0.0"); 3576 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp); 3577 EXPECT_TRUE(f1.isNaN()); 3578 } 3579 { 3580 APFloat f1(APFloat::IEEEdouble(), "0.0"); 3581 APFloat f2(APFloat::IEEEdouble(), "0.0"); 3582 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp); 3583 EXPECT_TRUE(f1.isNaN()); 3584 } 3585 { 3586 APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false); 3587 APFloat f2(APFloat::IEEEdouble(), "1.0"); 3588 EXPECT_EQ(f1.mod(f2), APFloat::opInvalidOp); 3589 EXPECT_TRUE(f1.isNaN()); 3590 } 3591 { 3592 APFloat f1(APFloat::IEEEdouble(), "-4.0"); 3593 APFloat f2(APFloat::IEEEdouble(), "-2.0"); 3594 APFloat expected(APFloat::IEEEdouble(), "-0.0"); 3595 EXPECT_EQ(f1.mod(f2), APFloat::opOK); 3596 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 3597 } 3598 { 3599 APFloat f1(APFloat::IEEEdouble(), "-4.0"); 3600 APFloat f2(APFloat::IEEEdouble(), "2.0"); 3601 APFloat expected(APFloat::IEEEdouble(), "-0.0"); 3602 EXPECT_EQ(f1.mod(f2), APFloat::opOK); 3603 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 3604 } 3605 } 3606 3607 TEST(APFloatTest, remainder) { 3608 // Test Special Cases against each other and normal values. 3609 3610 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle(), false); 3611 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle(), true); 3612 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle(), false); 3613 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle(), true); 3614 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle(), false); 3615 APFloat SNaN = APFloat(APFloat::IEEEsingle(), "snan123"); 3616 APFloat PNormalValue = APFloat(APFloat::IEEEsingle(), "0x1p+0"); 3617 APFloat MNormalValue = APFloat(APFloat::IEEEsingle(), "-0x1p+0"); 3618 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), false); 3619 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle(), true); 3620 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), false); 3621 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle(), true); 3622 APFloat PSmallestNormalized = 3623 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), false); 3624 APFloat MSmallestNormalized = 3625 APFloat::getSmallestNormalized(APFloat::IEEEsingle(), true); 3626 3627 APFloat PVal1(APFloat::IEEEsingle(), "0x1.fffffep+126"); 3628 APFloat MVal1(APFloat::IEEEsingle(), "-0x1.fffffep+126"); 3629 APFloat PVal2(APFloat::IEEEsingle(), "0x1.fffffep-126"); 3630 APFloat MVal2(APFloat::IEEEsingle(), "-0x1.fffffep-126"); 3631 APFloat PVal3(APFloat::IEEEsingle(), "0x1p-125"); 3632 APFloat MVal3(APFloat::IEEEsingle(), "-0x1p-125"); 3633 APFloat PVal4(APFloat::IEEEsingle(), "0x1p+127"); 3634 APFloat MVal4(APFloat::IEEEsingle(), "-0x1p+127"); 3635 APFloat PVal5(APFloat::IEEEsingle(), "1.5"); 3636 APFloat MVal5(APFloat::IEEEsingle(), "-1.5"); 3637 APFloat PVal6(APFloat::IEEEsingle(), "1"); 3638 APFloat MVal6(APFloat::IEEEsingle(), "-1"); 3639 3640 struct { 3641 APFloat x; 3642 APFloat y; 3643 const char *result; 3644 int status; 3645 int category; 3646 } SpecialCaseTests[] = { 3647 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3648 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3649 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3650 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3651 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 3652 { PInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3653 { PInf, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3654 { PInf, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3655 { PInf, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3656 { PInf, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3657 { PInf, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3658 { PInf, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3659 { PInf, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3660 { PInf, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3661 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3662 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3663 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3664 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3665 { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 3666 { MInf, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3667 { MInf, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3668 { MInf, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3669 { MInf, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3670 { MInf, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3671 { MInf, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3672 { MInf, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3673 { MInf, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3674 { MInf, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3675 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3676 { PZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3677 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3678 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3679 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 3680 { PZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3681 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3682 { PZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3683 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3684 { PZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3685 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3686 { PZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3687 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3688 { PZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3689 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3690 { MZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3691 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3692 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3693 { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 3694 { MZero, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3695 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3696 { MZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3697 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3698 { MZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3699 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3700 { MZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3701 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3702 { MZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3703 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 3704 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, 3705 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 3706 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN }, 3707 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 3708 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3709 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 3710 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 3711 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 3712 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 3713 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 3714 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 3715 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 3716 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 3717 { SNaN, PInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3718 { SNaN, MInf, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3719 { SNaN, PZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3720 { SNaN, MZero, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3721 { SNaN, QNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3722 { SNaN, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3723 { SNaN, PNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3724 { SNaN, MNormalValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3725 { SNaN, PLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3726 { SNaN, MLargestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3727 { SNaN, PSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3728 { SNaN, MSmallestValue, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3729 { SNaN, PSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3730 { SNaN, MSmallestNormalized, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3731 { PNormalValue, PInf, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 3732 { PNormalValue, MInf, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 3733 { PNormalValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3734 { PNormalValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3735 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 3736 { PNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3737 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3738 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3739 { PNormalValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 3740 { PNormalValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 3741 { PNormalValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3742 { PNormalValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3743 { PNormalValue, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3744 { PNormalValue, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3745 { MNormalValue, PInf, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 3746 { MNormalValue, MInf, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 3747 { MNormalValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3748 { MNormalValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3749 { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 3750 { MNormalValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3751 { MNormalValue, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3752 { MNormalValue, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3753 { MNormalValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 3754 { MNormalValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 3755 { MNormalValue, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3756 { MNormalValue, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3757 { MNormalValue, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3758 { MNormalValue, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3759 { PLargestValue, PInf, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 3760 { PLargestValue, MInf, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 3761 { PLargestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3762 { PLargestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3763 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 3764 { PLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3765 { PLargestValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3766 { PLargestValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3767 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3768 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3769 { PLargestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3770 { PLargestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3771 { PLargestValue, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3772 { PLargestValue, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3773 { MLargestValue, PInf, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 3774 { MLargestValue, MInf, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 3775 { MLargestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3776 { MLargestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3777 { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 3778 { MLargestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3779 { MLargestValue, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3780 { MLargestValue, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3781 { MLargestValue, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3782 { MLargestValue, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3783 { MLargestValue, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3784 { MLargestValue, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3785 { MLargestValue, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3786 { MLargestValue, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3787 { PSmallestValue, PInf, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 3788 { PSmallestValue, MInf, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 3789 { PSmallestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3790 { PSmallestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3791 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 3792 { PSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3793 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 3794 { PSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 3795 { PSmallestValue, PLargestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 3796 { PSmallestValue, MLargestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 3797 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3798 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3799 { PSmallestValue, PSmallestNormalized, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 3800 { PSmallestValue, MSmallestNormalized, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 3801 { MSmallestValue, PInf, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 3802 { MSmallestValue, MInf, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 3803 { MSmallestValue, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3804 { MSmallestValue, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3805 { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 3806 { MSmallestValue, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3807 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 3808 { MSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 3809 { MSmallestValue, PLargestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 3810 { MSmallestValue, MLargestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 3811 { MSmallestValue, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3812 { MSmallestValue, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3813 { MSmallestValue, PSmallestNormalized, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 3814 { MSmallestValue, MSmallestNormalized, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 3815 { PSmallestNormalized, PInf, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 3816 { PSmallestNormalized, MInf, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 3817 { PSmallestNormalized, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3818 { PSmallestNormalized, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3819 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 3820 { PSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3821 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 3822 { PSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 3823 { PSmallestNormalized, PLargestValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 3824 { PSmallestNormalized, MLargestValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 3825 { PSmallestNormalized, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3826 { PSmallestNormalized, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3827 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3828 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3829 { MSmallestNormalized, PInf, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 3830 { MSmallestNormalized, MInf, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 3831 { MSmallestNormalized, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3832 { MSmallestNormalized, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 3833 { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 3834 { MSmallestNormalized, SNaN, "nan123", APFloat::opInvalidOp, APFloat::fcNaN }, 3835 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 3836 { MSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 3837 { MSmallestNormalized, PLargestValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 3838 { MSmallestNormalized, MLargestValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 3839 { MSmallestNormalized, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3840 { MSmallestNormalized, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3841 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3842 { MSmallestNormalized, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3843 3844 { PVal1, PVal1, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3845 { PVal1, MVal1, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3846 { PVal1, PVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3847 { PVal1, MVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3848 { PVal1, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3849 { PVal1, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3850 { PVal1, PVal4, "-0x1p+103", APFloat::opOK, APFloat::fcNormal }, 3851 { PVal1, MVal4, "-0x1p+103", APFloat::opOK, APFloat::fcNormal }, 3852 { PVal1, PVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3853 { PVal1, MVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3854 { PVal1, PVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3855 { PVal1, MVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3856 { MVal1, PVal1, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3857 { MVal1, MVal1, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3858 { MVal1, PVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3859 { MVal1, MVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3860 { MVal1, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3861 { MVal1, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3862 { MVal1, PVal4, "0x1p+103", APFloat::opOK, APFloat::fcNormal }, 3863 { MVal1, MVal4, "0x1p+103", APFloat::opOK, APFloat::fcNormal }, 3864 { MVal1, PVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3865 { MVal1, MVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3866 { MVal1, PVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3867 { MVal1, MVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3868 { PVal2, PVal1, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal }, 3869 { PVal2, MVal1, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal }, 3870 { PVal2, PVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3871 { PVal2, MVal2, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3872 { PVal2, PVal3, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal }, 3873 { PVal2, MVal3, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal }, 3874 { PVal2, PVal4, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal }, 3875 { PVal2, MVal4, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal }, 3876 { PVal2, PVal5, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal }, 3877 { PVal2, MVal5, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal }, 3878 { PVal2, PVal6, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal }, 3879 { PVal2, MVal6, "0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal }, 3880 { MVal2, PVal1, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal }, 3881 { MVal2, MVal1, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal }, 3882 { MVal2, PVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3883 { MVal2, MVal2, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3884 { MVal2, PVal3, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal }, 3885 { MVal2, MVal3, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal }, 3886 { MVal2, PVal4, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal }, 3887 { MVal2, MVal4, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal }, 3888 { MVal2, PVal5, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal }, 3889 { MVal2, MVal5, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal }, 3890 { MVal2, PVal6, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal }, 3891 { MVal2, MVal6, "-0x1.fffffep-126", APFloat::opOK, APFloat::fcNormal }, 3892 { PVal3, PVal1, "0x1p-125", APFloat::opOK, APFloat::fcNormal }, 3893 { PVal3, MVal1, "0x1p-125", APFloat::opOK, APFloat::fcNormal }, 3894 { PVal3, PVal2, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal }, 3895 { PVal3, MVal2, "0x0.000002p-126", APFloat::opOK, APFloat::fcNormal }, 3896 { PVal3, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3897 { PVal3, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3898 { PVal3, PVal4, "0x1p-125", APFloat::opOK, APFloat::fcNormal }, 3899 { PVal3, MVal4, "0x1p-125", APFloat::opOK, APFloat::fcNormal }, 3900 { PVal3, PVal5, "0x1p-125", APFloat::opOK, APFloat::fcNormal }, 3901 { PVal3, MVal5, "0x1p-125", APFloat::opOK, APFloat::fcNormal }, 3902 { PVal3, PVal6, "0x1p-125", APFloat::opOK, APFloat::fcNormal }, 3903 { PVal3, MVal6, "0x1p-125", APFloat::opOK, APFloat::fcNormal }, 3904 { MVal3, PVal1, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }, 3905 { MVal3, MVal1, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }, 3906 { MVal3, PVal2, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal }, 3907 { MVal3, MVal2, "-0x0.000002p-126", APFloat::opOK, APFloat::fcNormal }, 3908 { MVal3, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3909 { MVal3, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3910 { MVal3, PVal4, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }, 3911 { MVal3, MVal4, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }, 3912 { MVal3, PVal5, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }, 3913 { MVal3, MVal5, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }, 3914 { MVal3, PVal6, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }, 3915 { MVal3, MVal6, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }, 3916 { PVal4, PVal1, "0x1p+103", APFloat::opOK, APFloat::fcNormal }, 3917 { PVal4, MVal1, "0x1p+103", APFloat::opOK, APFloat::fcNormal }, 3918 { PVal4, PVal2, "0x0.002p-126", APFloat::opOK, APFloat::fcNormal }, 3919 { PVal4, MVal2, "0x0.002p-126", APFloat::opOK, APFloat::fcNormal }, 3920 { PVal4, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3921 { PVal4, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3922 { PVal4, PVal4, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3923 { PVal4, MVal4, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3924 { PVal4, PVal5, "0.5", APFloat::opOK, APFloat::fcNormal }, 3925 { PVal4, MVal5, "0.5", APFloat::opOK, APFloat::fcNormal }, 3926 { PVal4, PVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3927 { PVal4, MVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3928 { MVal4, PVal1, "-0x1p+103", APFloat::opOK, APFloat::fcNormal }, 3929 { MVal4, MVal1, "-0x1p+103", APFloat::opOK, APFloat::fcNormal }, 3930 { MVal4, PVal2, "-0x0.002p-126", APFloat::opOK, APFloat::fcNormal }, 3931 { MVal4, MVal2, "-0x0.002p-126", APFloat::opOK, APFloat::fcNormal }, 3932 { MVal4, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3933 { MVal4, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3934 { MVal4, PVal4, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3935 { MVal4, MVal4, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3936 { MVal4, PVal5, "-0.5", APFloat::opOK, APFloat::fcNormal }, 3937 { MVal4, MVal5, "-0.5", APFloat::opOK, APFloat::fcNormal }, 3938 { MVal4, PVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3939 { MVal4, MVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3940 { PVal5, PVal1, "1.5", APFloat::opOK, APFloat::fcNormal }, 3941 { PVal5, MVal1, "1.5", APFloat::opOK, APFloat::fcNormal }, 3942 { PVal5, PVal2, "0x0.00006p-126", APFloat::opOK, APFloat::fcNormal }, 3943 { PVal5, MVal2, "0x0.00006p-126", APFloat::opOK, APFloat::fcNormal }, 3944 { PVal5, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3945 { PVal5, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3946 { PVal5, PVal4, "1.5", APFloat::opOK, APFloat::fcNormal }, 3947 { PVal5, MVal4, "1.5", APFloat::opOK, APFloat::fcNormal }, 3948 { PVal5, PVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3949 { PVal5, MVal5, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3950 { PVal5, PVal6, "-0.5", APFloat::opOK, APFloat::fcNormal }, 3951 { PVal5, MVal6, "-0.5", APFloat::opOK, APFloat::fcNormal }, 3952 { MVal5, PVal1, "-1.5", APFloat::opOK, APFloat::fcNormal }, 3953 { MVal5, MVal1, "-1.5", APFloat::opOK, APFloat::fcNormal }, 3954 { MVal5, PVal2, "-0x0.00006p-126", APFloat::opOK, APFloat::fcNormal }, 3955 { MVal5, MVal2, "-0x0.00006p-126", APFloat::opOK, APFloat::fcNormal }, 3956 { MVal5, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3957 { MVal5, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3958 { MVal5, PVal4, "-1.5", APFloat::opOK, APFloat::fcNormal }, 3959 { MVal5, MVal4, "-1.5", APFloat::opOK, APFloat::fcNormal }, 3960 { MVal5, PVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3961 { MVal5, MVal5, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3962 { MVal5, PVal6, "0.5", APFloat::opOK, APFloat::fcNormal }, 3963 { MVal5, MVal6, "0.5", APFloat::opOK, APFloat::fcNormal }, 3964 { PVal6, PVal1, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 3965 { PVal6, MVal1, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 3966 { PVal6, PVal2, "0x0.00004p-126", APFloat::opOK, APFloat::fcNormal }, 3967 { PVal6, MVal2, "0x0.00004p-126", APFloat::opOK, APFloat::fcNormal }, 3968 { PVal6, PVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3969 { PVal6, MVal3, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3970 { PVal6, PVal4, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 3971 { PVal6, MVal4, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 3972 { PVal6, PVal5, "-0.5", APFloat::opOK, APFloat::fcNormal }, 3973 { PVal6, MVal5, "-0.5", APFloat::opOK, APFloat::fcNormal }, 3974 { PVal6, PVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3975 { PVal6, MVal6, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 3976 { MVal6, PVal1, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 3977 { MVal6, MVal1, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 3978 { MVal6, PVal2, "-0x0.00004p-126", APFloat::opOK, APFloat::fcNormal }, 3979 { MVal6, MVal2, "-0x0.00004p-126", APFloat::opOK, APFloat::fcNormal }, 3980 { MVal6, PVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3981 { MVal6, MVal3, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3982 { MVal6, PVal4, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 3983 { MVal6, MVal4, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 3984 { MVal6, PVal5, "0.5", APFloat::opOK, APFloat::fcNormal }, 3985 { MVal6, MVal5, "0.5", APFloat::opOK, APFloat::fcNormal }, 3986 { MVal6, PVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3987 { MVal6, MVal6, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 3988 }; 3989 3990 for (size_t i = 0; i < array_lengthof(SpecialCaseTests); ++i) { 3991 APFloat x(SpecialCaseTests[i].x); 3992 APFloat y(SpecialCaseTests[i].y); 3993 APFloat::opStatus status = x.remainder(y); 3994 3995 APFloat result(x.getSemantics(), SpecialCaseTests[i].result); 3996 3997 EXPECT_TRUE(result.bitwiseIsEqual(x)); 3998 EXPECT_EQ(SpecialCaseTests[i].status, (int)status); 3999 EXPECT_EQ(SpecialCaseTests[i].category, (int)x.getCategory()); 4000 } 4001 4002 { 4003 APFloat f1(APFloat::IEEEdouble(), "0x1.3333333333333p-2"); // 0.3 4004 APFloat f2(APFloat::IEEEdouble(), "0x1.47ae147ae147bp-7"); // 0.01 4005 APFloat expected(APFloat::IEEEdouble(), "-0x1.4p-56"); 4006 EXPECT_EQ(APFloat::opOK, f1.remainder(f2)); 4007 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 4008 } 4009 { 4010 APFloat f1(APFloat::IEEEdouble(), "0x1p64"); // 1.8446744073709552e19 4011 APFloat f2(APFloat::IEEEdouble(), "1.5"); 4012 APFloat expected(APFloat::IEEEdouble(), "-0.5"); 4013 EXPECT_EQ(APFloat::opOK, f1.remainder(f2)); 4014 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 4015 } 4016 { 4017 APFloat f1(APFloat::IEEEdouble(), "0x1p1000"); 4018 APFloat f2(APFloat::IEEEdouble(), "0x1p-1000"); 4019 APFloat expected(APFloat::IEEEdouble(), "0.0"); 4020 EXPECT_EQ(APFloat::opOK, f1.remainder(f2)); 4021 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 4022 } 4023 { 4024 APFloat f1 = APFloat::getInf(APFloat::IEEEdouble(), false); 4025 APFloat f2(APFloat::IEEEdouble(), "1.0"); 4026 EXPECT_EQ(f1.remainder(f2), APFloat::opInvalidOp); 4027 EXPECT_TRUE(f1.isNaN()); 4028 } 4029 { 4030 APFloat f1(APFloat::IEEEdouble(), "-4.0"); 4031 APFloat f2(APFloat::IEEEdouble(), "-2.0"); 4032 APFloat expected(APFloat::IEEEdouble(), "-0.0"); 4033 EXPECT_EQ(APFloat::opOK, f1.remainder(f2)); 4034 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 4035 } 4036 { 4037 APFloat f1(APFloat::IEEEdouble(), "-4.0"); 4038 APFloat f2(APFloat::IEEEdouble(), "2.0"); 4039 APFloat expected(APFloat::IEEEdouble(), "-0.0"); 4040 EXPECT_EQ(APFloat::opOK, f1.remainder(f2)); 4041 EXPECT_TRUE(f1.bitwiseIsEqual(expected)); 4042 } 4043 } 4044 4045 TEST(APFloatTest, PPCDoubleDoubleAddSpecial) { 4046 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, 4047 APFloat::fltCategory, APFloat::roundingMode>; 4048 DataType Data[] = { 4049 // (1 + 0) + (-1 + 0) = fcZero 4050 std::make_tuple(0x3ff0000000000000ull, 0, 0xbff0000000000000ull, 0, 4051 APFloat::fcZero, APFloat::rmNearestTiesToEven), 4052 // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity 4053 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 4054 0x7948000000000000ull, 0ull, APFloat::fcInfinity, 4055 APFloat::rmNearestTiesToEven), 4056 // TODO: change the 4th 0x75effffffffffffe to 0x75efffffffffffff when 4057 // semPPCDoubleDoubleLegacy is gone. 4058 // LDBL_MAX + (1.011111... >> (1023 - 106) + (1.1111111...0 >> (1023 - 4059 // 160))) = fcNormal 4060 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 4061 0x7947ffffffffffffull, 0x75effffffffffffeull, 4062 APFloat::fcNormal, APFloat::rmNearestTiesToEven), 4063 // LDBL_MAX + (1.1 >> (1023 - 106) + 0)) = fcInfinity 4064 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 4065 0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 4066 APFloat::fcInfinity, APFloat::rmNearestTiesToEven), 4067 // NaN + (1 + 0) = fcNaN 4068 std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0, 4069 APFloat::fcNaN, APFloat::rmNearestTiesToEven), 4070 }; 4071 4072 for (auto Tp : Data) { 4073 uint64_t Op1[2], Op2[2]; 4074 APFloat::fltCategory Expected; 4075 APFloat::roundingMode RM; 4076 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp; 4077 4078 { 4079 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 4080 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 4081 A1.add(A2, RM); 4082 4083 EXPECT_EQ(Expected, A1.getCategory()) 4084 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], 4085 Op2[0], Op2[1]) 4086 .str(); 4087 } 4088 { 4089 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 4090 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 4091 A2.add(A1, RM); 4092 4093 EXPECT_EQ(Expected, A2.getCategory()) 4094 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1], 4095 Op1[0], Op1[1]) 4096 .str(); 4097 } 4098 } 4099 } 4100 4101 TEST(APFloatTest, PPCDoubleDoubleAdd) { 4102 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, 4103 uint64_t, APFloat::roundingMode>; 4104 DataType Data[] = { 4105 // (1 + 0) + (1e-105 + 0) = (1 + 1e-105) 4106 std::make_tuple(0x3ff0000000000000ull, 0, 0x3960000000000000ull, 0, 4107 0x3ff0000000000000ull, 0x3960000000000000ull, 4108 APFloat::rmNearestTiesToEven), 4109 // (1 + 0) + (1e-106 + 0) = (1 + 1e-106) 4110 std::make_tuple(0x3ff0000000000000ull, 0, 0x3950000000000000ull, 0, 4111 0x3ff0000000000000ull, 0x3950000000000000ull, 4112 APFloat::rmNearestTiesToEven), 4113 // (1 + 1e-106) + (1e-106 + 0) = (1 + 1e-105) 4114 std::make_tuple(0x3ff0000000000000ull, 0x3950000000000000ull, 4115 0x3950000000000000ull, 0, 0x3ff0000000000000ull, 4116 0x3960000000000000ull, APFloat::rmNearestTiesToEven), 4117 // (1 + 0) + (epsilon + 0) = (1 + epsilon) 4118 std::make_tuple(0x3ff0000000000000ull, 0, 0x0000000000000001ull, 0, 4119 0x3ff0000000000000ull, 0x0000000000000001ull, 4120 APFloat::rmNearestTiesToEven), 4121 // TODO: change 0xf950000000000000 to 0xf940000000000000, when 4122 // semPPCDoubleDoubleLegacy is gone. 4123 // (DBL_MAX - 1 << (1023 - 105)) + (1 << (1023 - 53) + 0) = DBL_MAX + 4124 // 1.11111... << (1023 - 52) 4125 std::make_tuple(0x7fefffffffffffffull, 0xf950000000000000ull, 4126 0x7c90000000000000ull, 0, 0x7fefffffffffffffull, 4127 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven), 4128 // TODO: change 0xf950000000000000 to 0xf940000000000000, when 4129 // semPPCDoubleDoubleLegacy is gone. 4130 // (1 << (1023 - 53) + 0) + (DBL_MAX - 1 << (1023 - 105)) = DBL_MAX + 4131 // 1.11111... << (1023 - 52) 4132 std::make_tuple(0x7c90000000000000ull, 0, 0x7fefffffffffffffull, 4133 0xf950000000000000ull, 0x7fefffffffffffffull, 4134 0x7c8ffffffffffffeull, APFloat::rmNearestTiesToEven), 4135 }; 4136 4137 for (auto Tp : Data) { 4138 uint64_t Op1[2], Op2[2], Expected[2]; 4139 APFloat::roundingMode RM; 4140 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp; 4141 4142 { 4143 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 4144 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 4145 A1.add(A2, RM); 4146 4147 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0]) 4148 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], 4149 Op2[0], Op2[1]) 4150 .str(); 4151 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1]) 4152 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], 4153 Op2[0], Op2[1]) 4154 .str(); 4155 } 4156 { 4157 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 4158 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 4159 A2.add(A1, RM); 4160 4161 EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0]) 4162 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1], 4163 Op1[0], Op1[1]) 4164 .str(); 4165 EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1]) 4166 << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op2[0], Op2[1], 4167 Op1[0], Op1[1]) 4168 .str(); 4169 } 4170 } 4171 } 4172 4173 TEST(APFloatTest, PPCDoubleDoubleSubtract) { 4174 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, 4175 uint64_t, APFloat::roundingMode>; 4176 DataType Data[] = { 4177 // (1 + 0) - (-1e-105 + 0) = (1 + 1e-105) 4178 std::make_tuple(0x3ff0000000000000ull, 0, 0xb960000000000000ull, 0, 4179 0x3ff0000000000000ull, 0x3960000000000000ull, 4180 APFloat::rmNearestTiesToEven), 4181 // (1 + 0) - (-1e-106 + 0) = (1 + 1e-106) 4182 std::make_tuple(0x3ff0000000000000ull, 0, 0xb950000000000000ull, 0, 4183 0x3ff0000000000000ull, 0x3950000000000000ull, 4184 APFloat::rmNearestTiesToEven), 4185 }; 4186 4187 for (auto Tp : Data) { 4188 uint64_t Op1[2], Op2[2], Expected[2]; 4189 APFloat::roundingMode RM; 4190 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp; 4191 4192 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 4193 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 4194 A1.subtract(A2, RM); 4195 4196 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0]) 4197 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0], 4198 Op2[1]) 4199 .str(); 4200 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1]) 4201 << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0], 4202 Op2[1]) 4203 .str(); 4204 } 4205 } 4206 4207 TEST(APFloatTest, PPCDoubleDoubleMultiplySpecial) { 4208 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, 4209 APFloat::fltCategory, APFloat::roundingMode>; 4210 DataType Data[] = { 4211 // fcNaN * fcNaN = fcNaN 4212 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0, 4213 APFloat::fcNaN, APFloat::rmNearestTiesToEven), 4214 // fcNaN * fcZero = fcNaN 4215 std::make_tuple(0x7ff8000000000000ull, 0, 0, 0, APFloat::fcNaN, 4216 APFloat::rmNearestTiesToEven), 4217 // fcNaN * fcInfinity = fcNaN 4218 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff0000000000000ull, 0, 4219 APFloat::fcNaN, APFloat::rmNearestTiesToEven), 4220 // fcNaN * fcNormal = fcNaN 4221 std::make_tuple(0x7ff8000000000000ull, 0, 0x3ff0000000000000ull, 0, 4222 APFloat::fcNaN, APFloat::rmNearestTiesToEven), 4223 // fcInfinity * fcInfinity = fcInfinity 4224 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0, 4225 APFloat::fcInfinity, APFloat::rmNearestTiesToEven), 4226 // fcInfinity * fcZero = fcNaN 4227 std::make_tuple(0x7ff0000000000000ull, 0, 0, 0, APFloat::fcNaN, 4228 APFloat::rmNearestTiesToEven), 4229 // fcInfinity * fcNormal = fcInfinity 4230 std::make_tuple(0x7ff0000000000000ull, 0, 0x3ff0000000000000ull, 0, 4231 APFloat::fcInfinity, APFloat::rmNearestTiesToEven), 4232 // fcZero * fcZero = fcZero 4233 std::make_tuple(0, 0, 0, 0, APFloat::fcZero, 4234 APFloat::rmNearestTiesToEven), 4235 // fcZero * fcNormal = fcZero 4236 std::make_tuple(0, 0, 0x3ff0000000000000ull, 0, APFloat::fcZero, 4237 APFloat::rmNearestTiesToEven), 4238 }; 4239 4240 for (auto Tp : Data) { 4241 uint64_t Op1[2], Op2[2]; 4242 APFloat::fltCategory Expected; 4243 APFloat::roundingMode RM; 4244 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp; 4245 4246 { 4247 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 4248 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 4249 A1.multiply(A2, RM); 4250 4251 EXPECT_EQ(Expected, A1.getCategory()) 4252 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1], 4253 Op2[0], Op2[1]) 4254 .str(); 4255 } 4256 { 4257 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 4258 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 4259 A2.multiply(A1, RM); 4260 4261 EXPECT_EQ(Expected, A2.getCategory()) 4262 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1], 4263 Op1[0], Op1[1]) 4264 .str(); 4265 } 4266 } 4267 } 4268 4269 TEST(APFloatTest, PPCDoubleDoubleMultiply) { 4270 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, 4271 uint64_t, APFloat::roundingMode>; 4272 DataType Data[] = { 4273 // 1/3 * 3 = 1.0 4274 std::make_tuple(0x3fd5555555555555ull, 0x3c75555555555556ull, 4275 0x4008000000000000ull, 0, 0x3ff0000000000000ull, 0, 4276 APFloat::rmNearestTiesToEven), 4277 // (1 + epsilon) * (1 + 0) = fcZero 4278 std::make_tuple(0x3ff0000000000000ull, 0x0000000000000001ull, 4279 0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 4280 0x0000000000000001ull, APFloat::rmNearestTiesToEven), 4281 // (1 + epsilon) * (1 + epsilon) = 1 + 2 * epsilon 4282 std::make_tuple(0x3ff0000000000000ull, 0x0000000000000001ull, 4283 0x3ff0000000000000ull, 0x0000000000000001ull, 4284 0x3ff0000000000000ull, 0x0000000000000002ull, 4285 APFloat::rmNearestTiesToEven), 4286 // -(1 + epsilon) * (1 + epsilon) = -1 4287 std::make_tuple(0xbff0000000000000ull, 0x0000000000000001ull, 4288 0x3ff0000000000000ull, 0x0000000000000001ull, 4289 0xbff0000000000000ull, 0, APFloat::rmNearestTiesToEven), 4290 // (0.5 + 0) * (1 + 2 * epsilon) = 0.5 + epsilon 4291 std::make_tuple(0x3fe0000000000000ull, 0, 0x3ff0000000000000ull, 4292 0x0000000000000002ull, 0x3fe0000000000000ull, 4293 0x0000000000000001ull, APFloat::rmNearestTiesToEven), 4294 // (0.5 + 0) * (1 + epsilon) = 0.5 4295 std::make_tuple(0x3fe0000000000000ull, 0, 0x3ff0000000000000ull, 4296 0x0000000000000001ull, 0x3fe0000000000000ull, 0, 4297 APFloat::rmNearestTiesToEven), 4298 // __LDBL_MAX__ * (1 + 1 << 106) = inf 4299 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 4300 0x3ff0000000000000ull, 0x3950000000000000ull, 4301 0x7ff0000000000000ull, 0, APFloat::rmNearestTiesToEven), 4302 // __LDBL_MAX__ * (1 + 1 << 107) > __LDBL_MAX__, but not inf, yes =_=||| 4303 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 4304 0x3ff0000000000000ull, 0x3940000000000000ull, 4305 0x7fefffffffffffffull, 0x7c8fffffffffffffull, 4306 APFloat::rmNearestTiesToEven), 4307 // __LDBL_MAX__ * (1 + 1 << 108) = __LDBL_MAX__ 4308 std::make_tuple(0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 4309 0x3ff0000000000000ull, 0x3930000000000000ull, 4310 0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 4311 APFloat::rmNearestTiesToEven), 4312 }; 4313 4314 for (auto Tp : Data) { 4315 uint64_t Op1[2], Op2[2], Expected[2]; 4316 APFloat::roundingMode RM; 4317 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp; 4318 4319 { 4320 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 4321 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 4322 A1.multiply(A2, RM); 4323 4324 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0]) 4325 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1], 4326 Op2[0], Op2[1]) 4327 .str(); 4328 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1]) 4329 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op1[0], Op1[1], 4330 Op2[0], Op2[1]) 4331 .str(); 4332 } 4333 { 4334 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 4335 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 4336 A2.multiply(A1, RM); 4337 4338 EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0]) 4339 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1], 4340 Op1[0], Op1[1]) 4341 .str(); 4342 EXPECT_EQ(Expected[1], A2.bitcastToAPInt().getRawData()[1]) 4343 << formatv("({0:x} + {1:x}) * ({2:x} + {3:x})", Op2[0], Op2[1], 4344 Op1[0], Op1[1]) 4345 .str(); 4346 } 4347 } 4348 } 4349 4350 TEST(APFloatTest, PPCDoubleDoubleDivide) { 4351 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, 4352 uint64_t, APFloat::roundingMode>; 4353 // TODO: Only a sanity check for now. Add more edge cases when the 4354 // double-double algorithm is implemented. 4355 DataType Data[] = { 4356 // 1 / 3 = 1/3 4357 std::make_tuple(0x3ff0000000000000ull, 0, 0x4008000000000000ull, 0, 4358 0x3fd5555555555555ull, 0x3c75555555555556ull, 4359 APFloat::rmNearestTiesToEven), 4360 }; 4361 4362 for (auto Tp : Data) { 4363 uint64_t Op1[2], Op2[2], Expected[2]; 4364 APFloat::roundingMode RM; 4365 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp; 4366 4367 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 4368 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 4369 A1.divide(A2, RM); 4370 4371 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0]) 4372 << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0], 4373 Op2[1]) 4374 .str(); 4375 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1]) 4376 << formatv("({0:x} + {1:x}) / ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0], 4377 Op2[1]) 4378 .str(); 4379 } 4380 } 4381 4382 TEST(APFloatTest, PPCDoubleDoubleRemainder) { 4383 using DataType = 4384 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>; 4385 DataType Data[] = { 4386 // remainder(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53) 4387 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull, 4388 0x3ff4000000000000ull, 0x3ca4000000000000ull, 4389 0x3fe0000000000000ull, 0x3c90000000000000ull), 4390 // remainder(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (-0.5 - 0.5 << 53) 4391 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull, 4392 0x3ffc000000000000ull, 0x3cac000000000000ull, 4393 0xbfe0000000000000ull, 0xbc90000000000000ull), 4394 }; 4395 4396 for (auto Tp : Data) { 4397 uint64_t Op1[2], Op2[2], Expected[2]; 4398 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp; 4399 4400 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 4401 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 4402 A1.remainder(A2); 4403 4404 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0]) 4405 << formatv("remainder({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1], 4406 Op2[0], Op2[1]) 4407 .str(); 4408 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1]) 4409 << formatv("remainder(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], 4410 Op1[1], Op2[0], Op2[1]) 4411 .str(); 4412 } 4413 } 4414 4415 TEST(APFloatTest, PPCDoubleDoubleMod) { 4416 using DataType = 4417 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t>; 4418 DataType Data[] = { 4419 // mod(3.0 + 3.0 << 53, 1.25 + 1.25 << 53) = (0.5 + 0.5 << 53) 4420 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull, 4421 0x3ff4000000000000ull, 0x3ca4000000000000ull, 4422 0x3fe0000000000000ull, 0x3c90000000000000ull), 4423 // mod(3.0 + 3.0 << 53, 1.75 + 1.75 << 53) = (1.25 + 1.25 << 53) 4424 // 0xbc98000000000000 doesn't seem right, but it's what we currently have. 4425 // TODO: investigate 4426 std::make_tuple(0x4008000000000000ull, 0x3cb8000000000000ull, 4427 0x3ffc000000000000ull, 0x3cac000000000000ull, 4428 0x3ff4000000000001ull, 0xbc98000000000000ull), 4429 }; 4430 4431 for (auto Tp : Data) { 4432 uint64_t Op1[2], Op2[2], Expected[2]; 4433 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp; 4434 4435 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 4436 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 4437 A1.mod(A2); 4438 4439 EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0]) 4440 << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1], 4441 Op2[0], Op2[1]) 4442 .str(); 4443 EXPECT_EQ(Expected[1], A1.bitcastToAPInt().getRawData()[1]) 4444 << formatv("fmod(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1], 4445 Op2[0], Op2[1]) 4446 .str(); 4447 } 4448 } 4449 4450 TEST(APFloatTest, PPCDoubleDoubleFMA) { 4451 // Sanity check for now. 4452 APFloat A(APFloat::PPCDoubleDouble(), "2"); 4453 A.fusedMultiplyAdd(APFloat(APFloat::PPCDoubleDouble(), "3"), 4454 APFloat(APFloat::PPCDoubleDouble(), "4"), 4455 APFloat::rmNearestTiesToEven); 4456 EXPECT_EQ(APFloat::cmpEqual, 4457 APFloat(APFloat::PPCDoubleDouble(), "10").compare(A)); 4458 } 4459 4460 TEST(APFloatTest, PPCDoubleDoubleRoundToIntegral) { 4461 { 4462 APFloat A(APFloat::PPCDoubleDouble(), "1.5"); 4463 A.roundToIntegral(APFloat::rmNearestTiesToEven); 4464 EXPECT_EQ(APFloat::cmpEqual, 4465 APFloat(APFloat::PPCDoubleDouble(), "2").compare(A)); 4466 } 4467 { 4468 APFloat A(APFloat::PPCDoubleDouble(), "2.5"); 4469 A.roundToIntegral(APFloat::rmNearestTiesToEven); 4470 EXPECT_EQ(APFloat::cmpEqual, 4471 APFloat(APFloat::PPCDoubleDouble(), "2").compare(A)); 4472 } 4473 } 4474 4475 TEST(APFloatTest, PPCDoubleDoubleCompare) { 4476 using DataType = 4477 std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, APFloat::cmpResult>; 4478 4479 DataType Data[] = { 4480 // (1 + 0) = (1 + 0) 4481 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0, 4482 APFloat::cmpEqual), 4483 // (1 + 0) < (1.00...1 + 0) 4484 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0, 4485 APFloat::cmpLessThan), 4486 // (1.00...1 + 0) > (1 + 0) 4487 std::make_tuple(0x3ff0000000000001ull, 0, 0x3ff0000000000000ull, 0, 4488 APFloat::cmpGreaterThan), 4489 // (1 + 0) < (1 + epsilon) 4490 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 4491 0x0000000000000001ull, APFloat::cmpLessThan), 4492 // NaN != NaN 4493 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0, 4494 APFloat::cmpUnordered), 4495 // (1 + 0) != NaN 4496 std::make_tuple(0x3ff0000000000000ull, 0, 0x7ff8000000000000ull, 0, 4497 APFloat::cmpUnordered), 4498 // Inf = Inf 4499 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0, 4500 APFloat::cmpEqual), 4501 }; 4502 4503 for (auto Tp : Data) { 4504 uint64_t Op1[2], Op2[2]; 4505 APFloat::cmpResult Expected; 4506 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp; 4507 4508 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 4509 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 4510 EXPECT_EQ(Expected, A1.compare(A2)) 4511 << formatv("compare(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1], 4512 Op2[0], Op2[1]) 4513 .str(); 4514 } 4515 } 4516 4517 TEST(APFloatTest, PPCDoubleDoubleBitwiseIsEqual) { 4518 using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, bool>; 4519 4520 DataType Data[] = { 4521 // (1 + 0) = (1 + 0) 4522 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000000ull, 0, true), 4523 // (1 + 0) != (1.00...1 + 0) 4524 std::make_tuple(0x3ff0000000000000ull, 0, 0x3ff0000000000001ull, 0, 4525 false), 4526 // NaN = NaN 4527 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 0, true), 4528 // NaN != NaN with a different bit pattern 4529 std::make_tuple(0x7ff8000000000000ull, 0, 0x7ff8000000000000ull, 4530 0x3ff0000000000000ull, false), 4531 // Inf = Inf 4532 std::make_tuple(0x7ff0000000000000ull, 0, 0x7ff0000000000000ull, 0, true), 4533 }; 4534 4535 for (auto Tp : Data) { 4536 uint64_t Op1[2], Op2[2]; 4537 bool Expected; 4538 std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp; 4539 4540 APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1)); 4541 APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2)); 4542 EXPECT_EQ(Expected, A1.bitwiseIsEqual(A2)) 4543 << formatv("({0:x} + {1:x}) = ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0], 4544 Op2[1]) 4545 .str(); 4546 } 4547 } 4548 4549 TEST(APFloatTest, PPCDoubleDoubleHashValue) { 4550 uint64_t Data1[] = {0x3ff0000000000001ull, 0x0000000000000001ull}; 4551 uint64_t Data2[] = {0x3ff0000000000001ull, 0}; 4552 // The hash values are *hopefully* different. 4553 EXPECT_NE( 4554 hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data1))), 4555 hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data2)))); 4556 } 4557 4558 TEST(APFloatTest, PPCDoubleDoubleChangeSign) { 4559 uint64_t Data[] = { 4560 0x400f000000000000ull, 0xbcb0000000000000ull, 4561 }; 4562 APFloat Float(APFloat::PPCDoubleDouble(), APInt(128, 2, Data)); 4563 { 4564 APFloat Actual = 4565 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "1")); 4566 EXPECT_EQ(0x400f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]); 4567 EXPECT_EQ(0xbcb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]); 4568 } 4569 { 4570 APFloat Actual = 4571 APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "-1")); 4572 EXPECT_EQ(0xc00f000000000000ull, Actual.bitcastToAPInt().getRawData()[0]); 4573 EXPECT_EQ(0x3cb0000000000000ull, Actual.bitcastToAPInt().getRawData()[1]); 4574 } 4575 } 4576 4577 TEST(APFloatTest, PPCDoubleDoubleFactories) { 4578 { 4579 uint64_t Data[] = { 4580 0, 0, 4581 }; 4582 EXPECT_EQ(APInt(128, 2, Data), 4583 APFloat::getZero(APFloat::PPCDoubleDouble()).bitcastToAPInt()); 4584 } 4585 { 4586 uint64_t Data[] = { 4587 0x7fefffffffffffffull, 0x7c8ffffffffffffeull, 4588 }; 4589 EXPECT_EQ(APInt(128, 2, Data), 4590 APFloat::getLargest(APFloat::PPCDoubleDouble()).bitcastToAPInt()); 4591 } 4592 { 4593 uint64_t Data[] = { 4594 0x0000000000000001ull, 0, 4595 }; 4596 EXPECT_EQ( 4597 APInt(128, 2, Data), 4598 APFloat::getSmallest(APFloat::PPCDoubleDouble()).bitcastToAPInt()); 4599 } 4600 { 4601 uint64_t Data[] = {0x0360000000000000ull, 0}; 4602 EXPECT_EQ(APInt(128, 2, Data), 4603 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble()) 4604 .bitcastToAPInt()); 4605 } 4606 { 4607 uint64_t Data[] = { 4608 0x8000000000000000ull, 0x0000000000000000ull, 4609 }; 4610 EXPECT_EQ( 4611 APInt(128, 2, Data), 4612 APFloat::getZero(APFloat::PPCDoubleDouble(), true).bitcastToAPInt()); 4613 } 4614 { 4615 uint64_t Data[] = { 4616 0xffefffffffffffffull, 0xfc8ffffffffffffeull, 4617 }; 4618 EXPECT_EQ( 4619 APInt(128, 2, Data), 4620 APFloat::getLargest(APFloat::PPCDoubleDouble(), true).bitcastToAPInt()); 4621 } 4622 { 4623 uint64_t Data[] = { 4624 0x8000000000000001ull, 0x0000000000000000ull, 4625 }; 4626 EXPECT_EQ(APInt(128, 2, Data), 4627 APFloat::getSmallest(APFloat::PPCDoubleDouble(), true) 4628 .bitcastToAPInt()); 4629 } 4630 { 4631 uint64_t Data[] = { 4632 0x8360000000000000ull, 0x0000000000000000ull, 4633 }; 4634 EXPECT_EQ(APInt(128, 2, Data), 4635 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble(), true) 4636 .bitcastToAPInt()); 4637 } 4638 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isSmallest()); 4639 EXPECT_TRUE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isLargest()); 4640 } 4641 4642 TEST(APFloatTest, PPCDoubleDoubleIsDenormal) { 4643 EXPECT_TRUE(APFloat::getSmallest(APFloat::PPCDoubleDouble()).isDenormal()); 4644 EXPECT_FALSE(APFloat::getLargest(APFloat::PPCDoubleDouble()).isDenormal()); 4645 EXPECT_FALSE( 4646 APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble()).isDenormal()); 4647 { 4648 // (4 + 3) is not normalized 4649 uint64_t Data[] = { 4650 0x4010000000000000ull, 0x4008000000000000ull, 4651 }; 4652 EXPECT_TRUE( 4653 APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data)).isDenormal()); 4654 } 4655 } 4656 4657 TEST(APFloatTest, PPCDoubleDoubleScalbn) { 4658 // 3.0 + 3.0 << 53 4659 uint64_t Input[] = { 4660 0x4008000000000000ull, 0x3cb8000000000000ull, 4661 }; 4662 APFloat Result = 4663 scalbn(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), 1, 4664 APFloat::rmNearestTiesToEven); 4665 // 6.0 + 6.0 << 53 4666 EXPECT_EQ(0x4018000000000000ull, Result.bitcastToAPInt().getRawData()[0]); 4667 EXPECT_EQ(0x3cc8000000000000ull, Result.bitcastToAPInt().getRawData()[1]); 4668 } 4669 4670 TEST(APFloatTest, PPCDoubleDoubleFrexp) { 4671 // 3.0 + 3.0 << 53 4672 uint64_t Input[] = { 4673 0x4008000000000000ull, 0x3cb8000000000000ull, 4674 }; 4675 int Exp; 4676 // 0.75 + 0.75 << 53 4677 APFloat Result = 4678 frexp(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), Exp, 4679 APFloat::rmNearestTiesToEven); 4680 EXPECT_EQ(2, Exp); 4681 EXPECT_EQ(0x3fe8000000000000ull, Result.bitcastToAPInt().getRawData()[0]); 4682 EXPECT_EQ(0x3c98000000000000ull, Result.bitcastToAPInt().getRawData()[1]); 4683 } 4684 } 4685