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