APFloatTest.cpp revision 763c066dca324ac4b86e7f014fe580ae5ba29fa0
1//===- llvm/unittest/ADT/APFloat.cpp - APFloat unit tests ---------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#include "llvm/ADT/APFloat.h" 11#include "llvm/ADT/APSInt.h" 12#include "llvm/ADT/SmallString.h" 13#include "llvm/ADT/SmallVector.h" 14#include "llvm/Support/raw_ostream.h" 15#include "gtest/gtest.h" 16#include <ostream> 17#include <string> 18 19using namespace llvm; 20 21static double convertToDoubleFromString(const char *Str) { 22 llvm::APFloat F(0.0); 23 F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven); 24 return F.convertToDouble(); 25} 26 27static std::string convertToString(double d, unsigned Prec, unsigned Pad) { 28 llvm::SmallVector<char, 100> Buffer; 29 llvm::APFloat F(d); 30 F.toString(Buffer, Prec, Pad); 31 return std::string(Buffer.data(), Buffer.size()); 32} 33 34namespace { 35 36TEST(APFloatTest, isSignaling) { 37 // We test qNaN, -qNaN, +sNaN, -sNaN with and without payloads. *NOTE* The 38 // positive/negative distinction is included only since the getQNaN/getSNaN 39 // API provides the option. 40 APInt payload = APInt::getOneBitSet(4, 2); 41 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, false).isSignaling()); 42 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, true).isSignaling()); 43 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, false, &payload).isSignaling()); 44 EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, true, &payload).isSignaling()); 45 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false).isSignaling()); 46 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true).isSignaling()); 47 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false, &payload).isSignaling()); 48 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true, &payload).isSignaling()); 49} 50 51TEST(APFloatTest, next) { 52 53 APFloat test(APFloat::IEEEquad, APFloat::uninitialized); 54 APFloat expected(APFloat::IEEEquad, APFloat::uninitialized); 55 56 // 1. Test Special Cases Values. 57 // 58 // Test all special values for nextUp and nextDown perscribed by IEEE-754R 59 // 2008. These are: 60 // 1. +inf 61 // 2. -inf 62 // 3. getLargest() 63 // 4. -getLargest() 64 // 5. getSmallest() 65 // 6. -getSmallest() 66 // 7. qNaN 67 // 8. sNaN 68 // 9. +0 69 // 10. -0 70 71 // nextUp(+inf) = +inf. 72 test = APFloat::getInf(APFloat::IEEEquad, false); 73 expected = APFloat::getInf(APFloat::IEEEquad, false); 74 EXPECT_EQ(test.next(false), APFloat::opOK); 75 EXPECT_TRUE(test.isInfinity()); 76 EXPECT_TRUE(!test.isNegative()); 77 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 78 79 // nextDown(+inf) = -nextUp(-inf) = -(-getLargest()) = getLargest() 80 test = APFloat::getInf(APFloat::IEEEquad, false); 81 expected = APFloat::getLargest(APFloat::IEEEquad, false); 82 EXPECT_EQ(test.next(true), APFloat::opOK); 83 EXPECT_TRUE(!test.isNegative()); 84 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 85 86 // nextUp(-inf) = -getLargest() 87 test = APFloat::getInf(APFloat::IEEEquad, true); 88 expected = APFloat::getLargest(APFloat::IEEEquad, true); 89 EXPECT_EQ(test.next(false), APFloat::opOK); 90 EXPECT_TRUE(test.isNegative()); 91 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 92 93 // nextDown(-inf) = -nextUp(+inf) = -(+inf) = -inf. 94 test = APFloat::getInf(APFloat::IEEEquad, true); 95 expected = APFloat::getInf(APFloat::IEEEquad, true); 96 EXPECT_EQ(test.next(true), APFloat::opOK); 97 EXPECT_TRUE(test.isInfinity() && test.isNegative()); 98 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 99 100 // nextUp(getLargest()) = +inf 101 test = APFloat::getLargest(APFloat::IEEEquad, false); 102 expected = APFloat::getInf(APFloat::IEEEquad, false); 103 EXPECT_EQ(test.next(false), APFloat::opOK); 104 EXPECT_TRUE(test.isInfinity() && !test.isNegative()); 105 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 106 107 // nextDown(getLargest()) = -nextUp(-getLargest()) 108 // = -(-getLargest() + inc) 109 // = getLargest() - inc. 110 test = APFloat::getLargest(APFloat::IEEEquad, false); 111 expected = APFloat(APFloat::IEEEquad, 112 "0x1.fffffffffffffffffffffffffffep+16383"); 113 EXPECT_EQ(test.next(true), APFloat::opOK); 114 EXPECT_TRUE(!test.isInfinity() && !test.isNegative()); 115 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 116 117 // nextUp(-getLargest()) = -getLargest() + inc. 118 test = APFloat::getLargest(APFloat::IEEEquad, true); 119 expected = APFloat(APFloat::IEEEquad, 120 "-0x1.fffffffffffffffffffffffffffep+16383"); 121 EXPECT_EQ(test.next(false), APFloat::opOK); 122 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 123 124 // nextDown(-getLargest()) = -nextUp(getLargest()) = -(inf) = -inf. 125 test = APFloat::getLargest(APFloat::IEEEquad, true); 126 expected = APFloat::getInf(APFloat::IEEEquad, true); 127 EXPECT_EQ(test.next(true), APFloat::opOK); 128 EXPECT_TRUE(test.isInfinity() && test.isNegative()); 129 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 130 131 // nextUp(getSmallest()) = getSmallest() + inc. 132 test = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382"); 133 expected = APFloat(APFloat::IEEEquad, 134 "0x0.0000000000000000000000000002p-16382"); 135 EXPECT_EQ(test.next(false), APFloat::opOK); 136 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 137 138 // nextDown(getSmallest()) = -nextUp(-getSmallest()) = -(-0) = +0. 139 test = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382"); 140 expected = APFloat::getZero(APFloat::IEEEquad, false); 141 EXPECT_EQ(test.next(true), APFloat::opOK); 142 EXPECT_TRUE(test.isZero() && !test.isNegative()); 143 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 144 145 // nextUp(-getSmallest()) = -0. 146 test = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382"); 147 expected = APFloat::getZero(APFloat::IEEEquad, true); 148 EXPECT_EQ(test.next(false), APFloat::opOK); 149 EXPECT_TRUE(test.isZero() && test.isNegative()); 150 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 151 152 // nextDown(-getSmallest()) = -nextUp(getSmallest()) = -getSmallest() - inc. 153 test = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382"); 154 expected = APFloat(APFloat::IEEEquad, 155 "-0x0.0000000000000000000000000002p-16382"); 156 EXPECT_EQ(test.next(true), APFloat::opOK); 157 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 158 159 // nextUp(qNaN) = qNaN 160 test = APFloat::getQNaN(APFloat::IEEEquad, false); 161 expected = APFloat::getQNaN(APFloat::IEEEquad, false); 162 EXPECT_EQ(test.next(false), APFloat::opOK); 163 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 164 165 // nextDown(qNaN) = qNaN 166 test = APFloat::getQNaN(APFloat::IEEEquad, false); 167 expected = APFloat::getQNaN(APFloat::IEEEquad, false); 168 EXPECT_EQ(test.next(true), APFloat::opOK); 169 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 170 171 // nextUp(sNaN) = qNaN 172 test = APFloat::getSNaN(APFloat::IEEEquad, false); 173 expected = APFloat::getQNaN(APFloat::IEEEquad, false); 174 EXPECT_EQ(test.next(false), APFloat::opInvalidOp); 175 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 176 177 // nextDown(sNaN) = qNaN 178 test = APFloat::getSNaN(APFloat::IEEEquad, false); 179 expected = APFloat::getQNaN(APFloat::IEEEquad, false); 180 EXPECT_EQ(test.next(true), APFloat::opInvalidOp); 181 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 182 183 // nextUp(+0) = +getSmallest() 184 test = APFloat::getZero(APFloat::IEEEquad, false); 185 expected = APFloat::getSmallest(APFloat::IEEEquad, false); 186 EXPECT_EQ(test.next(false), APFloat::opOK); 187 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 188 189 // nextDown(+0) = -nextUp(-0) = -getSmallest() 190 test = APFloat::getZero(APFloat::IEEEquad, false); 191 expected = APFloat::getSmallest(APFloat::IEEEquad, true); 192 EXPECT_EQ(test.next(true), APFloat::opOK); 193 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 194 195 // nextUp(-0) = +getSmallest() 196 test = APFloat::getZero(APFloat::IEEEquad, true); 197 expected = APFloat::getSmallest(APFloat::IEEEquad, false); 198 EXPECT_EQ(test.next(false), APFloat::opOK); 199 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 200 201 // nextDown(-0) = -nextUp(0) = -getSmallest() 202 test = APFloat::getZero(APFloat::IEEEquad, true); 203 expected = APFloat::getSmallest(APFloat::IEEEquad, true); 204 EXPECT_EQ(test.next(true), APFloat::opOK); 205 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 206 207 // 2. Binade Boundary Tests. 208 209 // 2a. Test denormal <-> normal binade boundaries. 210 // * nextUp(+Largest Denormal) -> +Smallest Normal. 211 // * nextDown(-Largest Denormal) -> -Smallest Normal. 212 // * nextUp(-Smallest Normal) -> -Largest Denormal. 213 // * nextDown(+Smallest Normal) -> +Largest Denormal. 214 215 // nextUp(+Largest Denormal) -> +Smallest Normal. 216 test = APFloat(APFloat::IEEEquad, "0x0.ffffffffffffffffffffffffffffp-16382"); 217 expected = APFloat(APFloat::IEEEquad, 218 "0x1.0000000000000000000000000000p-16382"); 219 EXPECT_EQ(test.next(false), APFloat::opOK); 220 EXPECT_FALSE(test.isDenormal()); 221 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 222 223 // nextDown(-Largest Denormal) -> -Smallest Normal. 224 test = APFloat(APFloat::IEEEquad, 225 "-0x0.ffffffffffffffffffffffffffffp-16382"); 226 expected = APFloat(APFloat::IEEEquad, 227 "-0x1.0000000000000000000000000000p-16382"); 228 EXPECT_EQ(test.next(true), APFloat::opOK); 229 EXPECT_FALSE(test.isDenormal()); 230 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 231 232 // nextUp(-Smallest Normal) -> -LargestDenormal. 233 test = APFloat(APFloat::IEEEquad, 234 "-0x1.0000000000000000000000000000p-16382"); 235 expected = APFloat(APFloat::IEEEquad, 236 "-0x0.ffffffffffffffffffffffffffffp-16382"); 237 EXPECT_EQ(test.next(false), APFloat::opOK); 238 EXPECT_TRUE(test.isDenormal()); 239 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 240 241 // nextDown(+Smallest Normal) -> +Largest Denormal. 242 test = APFloat(APFloat::IEEEquad, 243 "+0x1.0000000000000000000000000000p-16382"); 244 expected = APFloat(APFloat::IEEEquad, 245 "+0x0.ffffffffffffffffffffffffffffp-16382"); 246 EXPECT_EQ(test.next(true), APFloat::opOK); 247 EXPECT_TRUE(test.isDenormal()); 248 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 249 250 // 2b. Test normal <-> normal binade boundaries. 251 // * nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1. 252 // * nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1. 253 // * nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary. 254 // * nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary. 255 256 // nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1. 257 test = APFloat(APFloat::IEEEquad, "-0x1p+1"); 258 expected = APFloat(APFloat::IEEEquad, 259 "-0x1.ffffffffffffffffffffffffffffp+0"); 260 EXPECT_EQ(test.next(false), APFloat::opOK); 261 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 262 263 // nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1. 264 test = APFloat(APFloat::IEEEquad, "0x1p+1"); 265 expected = APFloat(APFloat::IEEEquad, "0x1.ffffffffffffffffffffffffffffp+0"); 266 EXPECT_EQ(test.next(true), APFloat::opOK); 267 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 268 269 // nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary. 270 test = APFloat(APFloat::IEEEquad, "0x1.ffffffffffffffffffffffffffffp+0"); 271 expected = APFloat(APFloat::IEEEquad, "0x1p+1"); 272 EXPECT_EQ(test.next(false), APFloat::opOK); 273 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 274 275 // nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary. 276 test = APFloat(APFloat::IEEEquad, "-0x1.ffffffffffffffffffffffffffffp+0"); 277 expected = APFloat(APFloat::IEEEquad, "-0x1p+1"); 278 EXPECT_EQ(test.next(true), APFloat::opOK); 279 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 280 281 // 2c. Test using next at binade boundaries with a direction away from the 282 // binade boundary. Away from denormal <-> normal boundaries. 283 // 284 // This is to make sure that even though we are at a binade boundary, since 285 // we are rounding away, we do not trigger the binade boundary code. Thus we 286 // test: 287 // * nextUp(-Largest Denormal) -> -Largest Denormal + inc. 288 // * nextDown(+Largest Denormal) -> +Largest Denormal - inc. 289 // * nextUp(+Smallest Normal) -> +Smallest Normal + inc. 290 // * nextDown(-Smallest Normal) -> -Smallest Normal - inc. 291 292 // nextUp(-Largest Denormal) -> -Largest Denormal + inc. 293 test = APFloat(APFloat::IEEEquad, "-0x0.ffffffffffffffffffffffffffffp-16382"); 294 expected = APFloat(APFloat::IEEEquad, 295 "-0x0.fffffffffffffffffffffffffffep-16382"); 296 EXPECT_EQ(test.next(false), APFloat::opOK); 297 EXPECT_TRUE(test.isDenormal()); 298 EXPECT_TRUE(test.isNegative()); 299 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 300 301 // nextDown(+Largest Denormal) -> +Largest Denormal - inc. 302 test = APFloat(APFloat::IEEEquad, "0x0.ffffffffffffffffffffffffffffp-16382"); 303 expected = APFloat(APFloat::IEEEquad, 304 "0x0.fffffffffffffffffffffffffffep-16382"); 305 EXPECT_EQ(test.next(true), APFloat::opOK); 306 EXPECT_TRUE(test.isDenormal()); 307 EXPECT_TRUE(!test.isNegative()); 308 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 309 310 // nextUp(+Smallest Normal) -> +Smallest Normal + inc. 311 test = APFloat(APFloat::IEEEquad, "0x1.0000000000000000000000000000p-16382"); 312 expected = APFloat(APFloat::IEEEquad, 313 "0x1.0000000000000000000000000001p-16382"); 314 EXPECT_EQ(test.next(false), APFloat::opOK); 315 EXPECT_TRUE(!test.isDenormal()); 316 EXPECT_TRUE(!test.isNegative()); 317 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 318 319 // nextDown(-Smallest Normal) -> -Smallest Normal - inc. 320 test = APFloat(APFloat::IEEEquad, "-0x1.0000000000000000000000000000p-16382"); 321 expected = APFloat(APFloat::IEEEquad, 322 "-0x1.0000000000000000000000000001p-16382"); 323 EXPECT_EQ(test.next(true), APFloat::opOK); 324 EXPECT_TRUE(!test.isDenormal()); 325 EXPECT_TRUE(test.isNegative()); 326 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 327 328 // 2d. Test values which cause our exponent to go to min exponent. This 329 // is to ensure that guards in the code to check for min exponent 330 // trigger properly. 331 // * nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382 332 // * nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) -> 333 // -0x1p-16381 334 // * nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16382 335 // * nextDown(0x1p-16382) -> 0x1.ffffffffffffffffffffffffffffp-16382 336 337 // nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382 338 test = APFloat(APFloat::IEEEquad, "-0x1p-16381"); 339 expected = APFloat(APFloat::IEEEquad, 340 "-0x1.ffffffffffffffffffffffffffffp-16382"); 341 EXPECT_EQ(test.next(false), APFloat::opOK); 342 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 343 344 // nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) -> 345 // -0x1p-16381 346 test = APFloat(APFloat::IEEEquad, "-0x1.ffffffffffffffffffffffffffffp-16382"); 347 expected = APFloat(APFloat::IEEEquad, "-0x1p-16381"); 348 EXPECT_EQ(test.next(true), APFloat::opOK); 349 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 350 351 // nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16381 352 test = APFloat(APFloat::IEEEquad, "0x1.ffffffffffffffffffffffffffffp-16382"); 353 expected = APFloat(APFloat::IEEEquad, "0x1p-16381"); 354 EXPECT_EQ(test.next(false), APFloat::opOK); 355 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 356 357 // nextDown(0x1p-16381) -> 0x1.ffffffffffffffffffffffffffffp-16382 358 test = APFloat(APFloat::IEEEquad, "0x1p-16381"); 359 expected = APFloat(APFloat::IEEEquad, 360 "0x1.ffffffffffffffffffffffffffffp-16382"); 361 EXPECT_EQ(test.next(true), APFloat::opOK); 362 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 363 364 // 3. Now we test both denormal/normal computation which will not cause us 365 // to go across binade boundaries. Specifically we test: 366 // * nextUp(+Denormal) -> +Denormal. 367 // * nextDown(+Denormal) -> +Denormal. 368 // * nextUp(-Denormal) -> -Denormal. 369 // * nextDown(-Denormal) -> -Denormal. 370 // * nextUp(+Normal) -> +Normal. 371 // * nextDown(+Normal) -> +Normal. 372 // * nextUp(-Normal) -> -Normal. 373 // * nextDown(-Normal) -> -Normal. 374 375 // nextUp(+Denormal) -> +Denormal. 376 test = APFloat(APFloat::IEEEquad, 377 "0x0.ffffffffffffffffffffffff000cp-16382"); 378 expected = APFloat(APFloat::IEEEquad, 379 "0x0.ffffffffffffffffffffffff000dp-16382"); 380 EXPECT_EQ(test.next(false), APFloat::opOK); 381 EXPECT_TRUE(test.isDenormal()); 382 EXPECT_TRUE(!test.isNegative()); 383 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 384 385 // nextDown(+Denormal) -> +Denormal. 386 test = APFloat(APFloat::IEEEquad, 387 "0x0.ffffffffffffffffffffffff000cp-16382"); 388 expected = APFloat(APFloat::IEEEquad, 389 "0x0.ffffffffffffffffffffffff000bp-16382"); 390 EXPECT_EQ(test.next(true), APFloat::opOK); 391 EXPECT_TRUE(test.isDenormal()); 392 EXPECT_TRUE(!test.isNegative()); 393 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 394 395 // nextUp(-Denormal) -> -Denormal. 396 test = APFloat(APFloat::IEEEquad, 397 "-0x0.ffffffffffffffffffffffff000cp-16382"); 398 expected = APFloat(APFloat::IEEEquad, 399 "-0x0.ffffffffffffffffffffffff000bp-16382"); 400 EXPECT_EQ(test.next(false), APFloat::opOK); 401 EXPECT_TRUE(test.isDenormal()); 402 EXPECT_TRUE(test.isNegative()); 403 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 404 405 // nextDown(-Denormal) -> -Denormal 406 test = APFloat(APFloat::IEEEquad, 407 "-0x0.ffffffffffffffffffffffff000cp-16382"); 408 expected = APFloat(APFloat::IEEEquad, 409 "-0x0.ffffffffffffffffffffffff000dp-16382"); 410 EXPECT_EQ(test.next(true), APFloat::opOK); 411 EXPECT_TRUE(test.isDenormal()); 412 EXPECT_TRUE(test.isNegative()); 413 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 414 415 // nextUp(+Normal) -> +Normal. 416 test = APFloat(APFloat::IEEEquad, 417 "0x1.ffffffffffffffffffffffff000cp-16000"); 418 expected = APFloat(APFloat::IEEEquad, 419 "0x1.ffffffffffffffffffffffff000dp-16000"); 420 EXPECT_EQ(test.next(false), APFloat::opOK); 421 EXPECT_TRUE(!test.isDenormal()); 422 EXPECT_TRUE(!test.isNegative()); 423 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 424 425 // nextDown(+Normal) -> +Normal. 426 test = APFloat(APFloat::IEEEquad, 427 "0x1.ffffffffffffffffffffffff000cp-16000"); 428 expected = APFloat(APFloat::IEEEquad, 429 "0x1.ffffffffffffffffffffffff000bp-16000"); 430 EXPECT_EQ(test.next(true), APFloat::opOK); 431 EXPECT_TRUE(!test.isDenormal()); 432 EXPECT_TRUE(!test.isNegative()); 433 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 434 435 // nextUp(-Normal) -> -Normal. 436 test = APFloat(APFloat::IEEEquad, 437 "-0x1.ffffffffffffffffffffffff000cp-16000"); 438 expected = APFloat(APFloat::IEEEquad, 439 "-0x1.ffffffffffffffffffffffff000bp-16000"); 440 EXPECT_EQ(test.next(false), APFloat::opOK); 441 EXPECT_TRUE(!test.isDenormal()); 442 EXPECT_TRUE(test.isNegative()); 443 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 444 445 // nextDown(-Normal) -> -Normal. 446 test = APFloat(APFloat::IEEEquad, 447 "-0x1.ffffffffffffffffffffffff000cp-16000"); 448 expected = APFloat(APFloat::IEEEquad, 449 "-0x1.ffffffffffffffffffffffff000dp-16000"); 450 EXPECT_EQ(test.next(true), APFloat::opOK); 451 EXPECT_TRUE(!test.isDenormal()); 452 EXPECT_TRUE(test.isNegative()); 453 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 454} 455 456TEST(APFloatTest, FMA) { 457 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven; 458 459 { 460 APFloat f1(14.5f); 461 APFloat f2(-14.5f); 462 APFloat f3(225.0f); 463 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven); 464 EXPECT_EQ(14.75f, f1.convertToFloat()); 465 } 466 467 { 468 APFloat Val2(2.0f); 469 APFloat f1((float)1.17549435e-38F); 470 APFloat f2((float)1.17549435e-38F); 471 f1.divide(Val2, rdmd); 472 f2.divide(Val2, rdmd); 473 APFloat f3(12.0f); 474 f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven); 475 EXPECT_EQ(12.0f, f1.convertToFloat()); 476 } 477} 478 479TEST(APFloatTest, Denormal) { 480 APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven; 481 482 // Test single precision 483 { 484 const char *MinNormalStr = "1.17549435082228750797e-38"; 485 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, MinNormalStr).isDenormal()); 486 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, 0.0).isDenormal()); 487 488 APFloat Val2(APFloat::IEEEsingle, 2.0e0); 489 APFloat T(APFloat::IEEEsingle, MinNormalStr); 490 T.divide(Val2, rdmd); 491 EXPECT_TRUE(T.isDenormal()); 492 } 493 494 // Test double precision 495 { 496 const char *MinNormalStr = "2.22507385850720138309e-308"; 497 EXPECT_FALSE(APFloat(APFloat::IEEEdouble, MinNormalStr).isDenormal()); 498 EXPECT_FALSE(APFloat(APFloat::IEEEdouble, 0.0).isDenormal()); 499 500 APFloat Val2(APFloat::IEEEdouble, 2.0e0); 501 APFloat T(APFloat::IEEEdouble, MinNormalStr); 502 T.divide(Val2, rdmd); 503 EXPECT_TRUE(T.isDenormal()); 504 } 505 506 // Test Intel double-ext 507 { 508 const char *MinNormalStr = "3.36210314311209350626e-4932"; 509 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended, MinNormalStr).isDenormal()); 510 EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended, 0.0).isDenormal()); 511 512 APFloat Val2(APFloat::x87DoubleExtended, 2.0e0); 513 APFloat T(APFloat::x87DoubleExtended, MinNormalStr); 514 T.divide(Val2, rdmd); 515 EXPECT_TRUE(T.isDenormal()); 516 } 517 518 // Test quadruple precision 519 { 520 const char *MinNormalStr = "3.36210314311209350626267781732175260e-4932"; 521 EXPECT_FALSE(APFloat(APFloat::IEEEquad, MinNormalStr).isDenormal()); 522 EXPECT_FALSE(APFloat(APFloat::IEEEquad, 0.0).isDenormal()); 523 524 APFloat Val2(APFloat::IEEEquad, 2.0e0); 525 APFloat T(APFloat::IEEEquad, MinNormalStr); 526 T.divide(Val2, rdmd); 527 EXPECT_TRUE(T.isDenormal()); 528 } 529} 530 531TEST(APFloatTest, Zero) { 532 EXPECT_EQ(0.0f, APFloat(0.0f).convertToFloat()); 533 EXPECT_EQ(-0.0f, APFloat(-0.0f).convertToFloat()); 534 EXPECT_TRUE(APFloat(-0.0f).isNegative()); 535 536 EXPECT_EQ(0.0, APFloat(0.0).convertToDouble()); 537 EXPECT_EQ(-0.0, APFloat(-0.0).convertToDouble()); 538 EXPECT_TRUE(APFloat(-0.0).isNegative()); 539} 540 541TEST(APFloatTest, DecimalStringsWithoutNullTerminators) { 542 // Make sure that we can parse strings without null terminators. 543 // rdar://14323230. 544 APFloat Val(APFloat::IEEEdouble); 545 Val.convertFromString(StringRef("0.00", 3), 546 llvm::APFloat::rmNearestTiesToEven); 547 EXPECT_EQ(Val.convertToDouble(), 0.0); 548 Val.convertFromString(StringRef("0.01", 3), 549 llvm::APFloat::rmNearestTiesToEven); 550 EXPECT_EQ(Val.convertToDouble(), 0.0); 551 Val.convertFromString(StringRef("0.09", 3), 552 llvm::APFloat::rmNearestTiesToEven); 553 EXPECT_EQ(Val.convertToDouble(), 0.0); 554 Val.convertFromString(StringRef("0.095", 4), 555 llvm::APFloat::rmNearestTiesToEven); 556 EXPECT_EQ(Val.convertToDouble(), 0.09); 557 Val.convertFromString(StringRef("0.00e+3", 7), 558 llvm::APFloat::rmNearestTiesToEven); 559 EXPECT_EQ(Val.convertToDouble(), 0.00); 560 Val.convertFromString(StringRef("0e+3", 4), 561 llvm::APFloat::rmNearestTiesToEven); 562 EXPECT_EQ(Val.convertToDouble(), 0.00); 563 564} 565 566TEST(APFloatTest, fromZeroDecimalString) { 567 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0").convertToDouble()); 568 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0").convertToDouble()); 569 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0").convertToDouble()); 570 571 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.").convertToDouble()); 572 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.").convertToDouble()); 573 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.").convertToDouble()); 574 575 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0").convertToDouble()); 576 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0").convertToDouble()); 577 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0").convertToDouble()); 578 579 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0").convertToDouble()); 580 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0").convertToDouble()); 581 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0").convertToDouble()); 582 583 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "00000.").convertToDouble()); 584 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+00000.").convertToDouble()); 585 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-00000.").convertToDouble()); 586 587 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, ".00000").convertToDouble()); 588 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.00000").convertToDouble()); 589 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.00000").convertToDouble()); 590 591 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0000.00000").convertToDouble()); 592 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0000.00000").convertToDouble()); 593 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0000.00000").convertToDouble()); 594} 595 596TEST(APFloatTest, fromZeroDecimalSingleExponentString) { 597 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e1").convertToDouble()); 598 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e1").convertToDouble()); 599 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e1").convertToDouble()); 600 601 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e+1").convertToDouble()); 602 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e+1").convertToDouble()); 603 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e+1").convertToDouble()); 604 605 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e-1").convertToDouble()); 606 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e-1").convertToDouble()); 607 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e-1").convertToDouble()); 608 609 610 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.e1").convertToDouble()); 611 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e1").convertToDouble()); 612 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e1").convertToDouble()); 613 614 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.e+1").convertToDouble()); 615 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e+1").convertToDouble()); 616 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e+1").convertToDouble()); 617 618 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.e-1").convertToDouble()); 619 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e-1").convertToDouble()); 620 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e-1").convertToDouble()); 621 622 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0e1").convertToDouble()); 623 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e1").convertToDouble()); 624 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e1").convertToDouble()); 625 626 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0e+1").convertToDouble()); 627 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e+1").convertToDouble()); 628 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e+1").convertToDouble()); 629 630 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0e-1").convertToDouble()); 631 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e-1").convertToDouble()); 632 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e-1").convertToDouble()); 633 634 635 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0e1").convertToDouble()); 636 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e1").convertToDouble()); 637 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e1").convertToDouble()); 638 639 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0e+1").convertToDouble()); 640 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e+1").convertToDouble()); 641 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e+1").convertToDouble()); 642 643 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0e-1").convertToDouble()); 644 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e-1").convertToDouble()); 645 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e-1").convertToDouble()); 646 647 648 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "000.0000e1").convertToDouble()); 649 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+000.0000e+1").convertToDouble()); 650 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-000.0000e+1").convertToDouble()); 651} 652 653TEST(APFloatTest, fromZeroDecimalLargeExponentString) { 654 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e1234").convertToDouble()); 655 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e1234").convertToDouble()); 656 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e1234").convertToDouble()); 657 658 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e+1234").convertToDouble()); 659 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e+1234").convertToDouble()); 660 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e+1234").convertToDouble()); 661 662 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e-1234").convertToDouble()); 663 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e-1234").convertToDouble()); 664 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e-1234").convertToDouble()); 665 666 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, "000.0000e1234").convertToDouble()); 667 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, "000.0000e-1234").convertToDouble()); 668 669 EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, StringRef("0e1234\02", 6)).convertToDouble()); 670} 671 672TEST(APFloatTest, fromZeroHexadecimalString) { 673 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p1").convertToDouble()); 674 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p1").convertToDouble()); 675 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1").convertToDouble()); 676 677 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p+1").convertToDouble()); 678 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p+1").convertToDouble()); 679 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p+1").convertToDouble()); 680 681 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p-1").convertToDouble()); 682 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p-1").convertToDouble()); 683 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p-1").convertToDouble()); 684 685 686 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1").convertToDouble()); 687 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p1").convertToDouble()); 688 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p1").convertToDouble()); 689 690 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p+1").convertToDouble()); 691 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p+1").convertToDouble()); 692 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p+1").convertToDouble()); 693 694 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p-1").convertToDouble()); 695 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p-1").convertToDouble()); 696 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p-1").convertToDouble()); 697 698 699 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.0p1").convertToDouble()); 700 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p1").convertToDouble()); 701 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p1").convertToDouble()); 702 703 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.0p+1").convertToDouble()); 704 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p+1").convertToDouble()); 705 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p+1").convertToDouble()); 706 707 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.0p-1").convertToDouble()); 708 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p-1").convertToDouble()); 709 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p-1").convertToDouble()); 710 711 712 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.0p1").convertToDouble()); 713 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p1").convertToDouble()); 714 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p1").convertToDouble()); 715 716 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.0p+1").convertToDouble()); 717 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p+1").convertToDouble()); 718 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p+1").convertToDouble()); 719 720 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.0p-1").convertToDouble()); 721 EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p-1").convertToDouble()); 722 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p-1").convertToDouble()); 723 724 725 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1").convertToDouble()); 726 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1").convertToDouble()); 727 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1").convertToDouble()); 728 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1").convertToDouble()); 729 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p1234").convertToDouble()); 730 EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1234").convertToDouble()); 731 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1234").convertToDouble()); 732 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1234").convertToDouble()); 733 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1234").convertToDouble()); 734 EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1234").convertToDouble()); 735} 736 737TEST(APFloatTest, fromDecimalString) { 738 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "1").convertToDouble()); 739 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble, "2.").convertToDouble()); 740 EXPECT_EQ(0.5, APFloat(APFloat::IEEEdouble, ".5").convertToDouble()); 741 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "1.0").convertToDouble()); 742 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-2").convertToDouble()); 743 EXPECT_EQ(-4.0, APFloat(APFloat::IEEEdouble, "-4.").convertToDouble()); 744 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble, "-.5").convertToDouble()); 745 EXPECT_EQ(-1.5, APFloat(APFloat::IEEEdouble, "-1.5").convertToDouble()); 746 EXPECT_EQ(1.25e12, APFloat(APFloat::IEEEdouble, "1.25e12").convertToDouble()); 747 EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble, "1.25e+12").convertToDouble()); 748 EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble, "1.25e-12").convertToDouble()); 749 EXPECT_EQ(1024.0, APFloat(APFloat::IEEEdouble, "1024.").convertToDouble()); 750 EXPECT_EQ(1024.05, APFloat(APFloat::IEEEdouble, "1024.05000").convertToDouble()); 751 EXPECT_EQ(0.05, APFloat(APFloat::IEEEdouble, ".05000").convertToDouble()); 752 EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble, "2.").convertToDouble()); 753 EXPECT_EQ(2.0e2, APFloat(APFloat::IEEEdouble, "2.e2").convertToDouble()); 754 EXPECT_EQ(2.0e+2, APFloat(APFloat::IEEEdouble, "2.e+2").convertToDouble()); 755 EXPECT_EQ(2.0e-2, APFloat(APFloat::IEEEdouble, "2.e-2").convertToDouble()); 756 EXPECT_EQ(2.05e2, APFloat(APFloat::IEEEdouble, "002.05000e2").convertToDouble()); 757 EXPECT_EQ(2.05e+2, APFloat(APFloat::IEEEdouble, "002.05000e+2").convertToDouble()); 758 EXPECT_EQ(2.05e-2, APFloat(APFloat::IEEEdouble, "002.05000e-2").convertToDouble()); 759 EXPECT_EQ(2.05e12, APFloat(APFloat::IEEEdouble, "002.05000e12").convertToDouble()); 760 EXPECT_EQ(2.05e+12, APFloat(APFloat::IEEEdouble, "002.05000e+12").convertToDouble()); 761 EXPECT_EQ(2.05e-12, APFloat(APFloat::IEEEdouble, "002.05000e-12").convertToDouble()); 762 763 // These are "carefully selected" to overflow the fast log-base 764 // calculations in APFloat.cpp 765 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "99e99999").isInfinity()); 766 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-99e99999").isInfinity()); 767 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "1e-99999").isPosZero()); 768 EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-1e-99999").isNegZero()); 769 770 EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828")); 771} 772 773TEST(APFloatTest, fromHexadecimalString) { 774 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble, "0x1p0").convertToDouble()); 775 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p0").convertToDouble()); 776 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p0").convertToDouble()); 777 778 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble, "0x1p+0").convertToDouble()); 779 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p+0").convertToDouble()); 780 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p+0").convertToDouble()); 781 782 EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble, "0x1p-0").convertToDouble()); 783 EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p-0").convertToDouble()); 784 EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p-0").convertToDouble()); 785 786 787 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble, "0x1p1").convertToDouble()); 788 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble, "+0x1p1").convertToDouble()); 789 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-0x1p1").convertToDouble()); 790 791 EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble, "0x1p+1").convertToDouble()); 792 EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble, "+0x1p+1").convertToDouble()); 793 EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-0x1p+1").convertToDouble()); 794 795 EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble, "0x1p-1").convertToDouble()); 796 EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble, "+0x1p-1").convertToDouble()); 797 EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble, "-0x1p-1").convertToDouble()); 798 799 800 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble, "0x1.8p1").convertToDouble()); 801 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble, "+0x1.8p1").convertToDouble()); 802 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble, "-0x1.8p1").convertToDouble()); 803 804 EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble, "0x1.8p+1").convertToDouble()); 805 EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble, "+0x1.8p+1").convertToDouble()); 806 EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble, "-0x1.8p+1").convertToDouble()); 807 808 EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble, "0x1.8p-1").convertToDouble()); 809 EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble, "+0x1.8p-1").convertToDouble()); 810 EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble, "-0x1.8p-1").convertToDouble()); 811 812 813 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000.000p1").convertToDouble()); 814 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p1").convertToDouble()); 815 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p1").convertToDouble()); 816 817 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000.000p+1").convertToDouble()); 818 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p+1").convertToDouble()); 819 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p+1").convertToDouble()); 820 821 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble, "0x1000.000p-1").convertToDouble()); 822 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p-1").convertToDouble()); 823 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p-1").convertToDouble()); 824 825 826 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000p1").convertToDouble()); 827 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000p1").convertToDouble()); 828 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000p1").convertToDouble()); 829 830 EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000p+1").convertToDouble()); 831 EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000p+1").convertToDouble()); 832 EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000p+1").convertToDouble()); 833 834 EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble, "0x1000p-1").convertToDouble()); 835 EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble, "+0x1000p-1").convertToDouble()); 836 EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble, "-0x1000p-1").convertToDouble()); 837 838 839 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble, "0x10p10").convertToDouble()); 840 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble, "+0x10p10").convertToDouble()); 841 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble, "-0x10p10").convertToDouble()); 842 843 EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble, "0x10p+10").convertToDouble()); 844 EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble, "+0x10p+10").convertToDouble()); 845 EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble, "-0x10p+10").convertToDouble()); 846 847 EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble, "0x10p-10").convertToDouble()); 848 EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble, "+0x10p-10").convertToDouble()); 849 EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble, "-0x10p-10").convertToDouble()); 850 851 EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble, "0x1.1p0").convertToDouble()); 852 EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "0x1p0").convertToDouble()); 853 854 EXPECT_EQ(convertToDoubleFromString("0x1p-150"), 855 convertToDoubleFromString("+0x800000000000000001.p-221")); 856 EXPECT_EQ(2251799813685248.5, 857 convertToDoubleFromString("0x80000000000004000000.010p-28")); 858} 859 860TEST(APFloatTest, toString) { 861 ASSERT_EQ("10", convertToString(10.0, 6, 3)); 862 ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0)); 863 ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2)); 864 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2)); 865 ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1)); 866 ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2)); 867 ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2)); 868 ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1)); 869 ASSERT_EQ("0.7853981633974483", convertToString(0.78539816339744830961, 0, 3)); 870 ASSERT_EQ("4.940656458412465E-324", convertToString(4.9406564584124654e-324, 0, 3)); 871 ASSERT_EQ("873.1834", convertToString(873.1834, 0, 1)); 872 ASSERT_EQ("8.731834E+2", convertToString(873.1834, 0, 0)); 873} 874 875TEST(APFloatTest, toInteger) { 876 bool isExact = false; 877 APSInt result(5, /*isUnsigned=*/true); 878 879 EXPECT_EQ(APFloat::opOK, 880 APFloat(APFloat::IEEEdouble, "10") 881 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 882 EXPECT_TRUE(isExact); 883 EXPECT_EQ(APSInt(APInt(5, 10), true), result); 884 885 EXPECT_EQ(APFloat::opInvalidOp, 886 APFloat(APFloat::IEEEdouble, "-10") 887 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 888 EXPECT_FALSE(isExact); 889 EXPECT_EQ(APSInt::getMinValue(5, true), result); 890 891 EXPECT_EQ(APFloat::opInvalidOp, 892 APFloat(APFloat::IEEEdouble, "32") 893 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 894 EXPECT_FALSE(isExact); 895 EXPECT_EQ(APSInt::getMaxValue(5, true), result); 896 897 EXPECT_EQ(APFloat::opInexact, 898 APFloat(APFloat::IEEEdouble, "7.9") 899 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 900 EXPECT_FALSE(isExact); 901 EXPECT_EQ(APSInt(APInt(5, 7), true), result); 902 903 result.setIsUnsigned(false); 904 EXPECT_EQ(APFloat::opOK, 905 APFloat(APFloat::IEEEdouble, "-10") 906 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 907 EXPECT_TRUE(isExact); 908 EXPECT_EQ(APSInt(APInt(5, -10, true), false), result); 909 910 EXPECT_EQ(APFloat::opInvalidOp, 911 APFloat(APFloat::IEEEdouble, "-17") 912 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 913 EXPECT_FALSE(isExact); 914 EXPECT_EQ(APSInt::getMinValue(5, false), result); 915 916 EXPECT_EQ(APFloat::opInvalidOp, 917 APFloat(APFloat::IEEEdouble, "16") 918 .convertToInteger(result, APFloat::rmTowardZero, &isExact)); 919 EXPECT_FALSE(isExact); 920 EXPECT_EQ(APSInt::getMaxValue(5, false), result); 921} 922 923static APInt nanbits(const fltSemantics &Sem, 924 bool SNaN, bool Negative, uint64_t fill) { 925 APInt apfill(64, fill); 926 if (SNaN) 927 return APFloat::getSNaN(Sem, Negative, &apfill).bitcastToAPInt(); 928 else 929 return APFloat::getQNaN(Sem, Negative, &apfill).bitcastToAPInt(); 930} 931 932TEST(APFloatTest, makeNaN) { 933 ASSERT_EQ(0x7fc00000, nanbits(APFloat::IEEEsingle, false, false, 0)); 934 ASSERT_EQ(0xffc00000, nanbits(APFloat::IEEEsingle, false, true, 0)); 935 ASSERT_EQ(0x7fc0ae72, nanbits(APFloat::IEEEsingle, false, false, 0xae72)); 936 ASSERT_EQ(0x7fffae72, nanbits(APFloat::IEEEsingle, false, false, 0xffffae72)); 937 ASSERT_EQ(0x7fa00000, nanbits(APFloat::IEEEsingle, true, false, 0)); 938 ASSERT_EQ(0xffa00000, nanbits(APFloat::IEEEsingle, true, true, 0)); 939 ASSERT_EQ(0x7f80ae72, nanbits(APFloat::IEEEsingle, true, false, 0xae72)); 940 ASSERT_EQ(0x7fbfae72, nanbits(APFloat::IEEEsingle, true, false, 0xffffae72)); 941 942 ASSERT_EQ(0x7ff8000000000000ULL, nanbits(APFloat::IEEEdouble, false, false, 0)); 943 ASSERT_EQ(0xfff8000000000000ULL, nanbits(APFloat::IEEEdouble, false, true, 0)); 944 ASSERT_EQ(0x7ff800000000ae72ULL, nanbits(APFloat::IEEEdouble, false, false, 0xae72)); 945 ASSERT_EQ(0x7fffffffffffae72ULL, nanbits(APFloat::IEEEdouble, false, false, 0xffffffffffffae72ULL)); 946 ASSERT_EQ(0x7ff4000000000000ULL, nanbits(APFloat::IEEEdouble, true, false, 0)); 947 ASSERT_EQ(0xfff4000000000000ULL, nanbits(APFloat::IEEEdouble, true, true, 0)); 948 ASSERT_EQ(0x7ff000000000ae72ULL, nanbits(APFloat::IEEEdouble, true, false, 0xae72)); 949 ASSERT_EQ(0x7ff7ffffffffae72ULL, nanbits(APFloat::IEEEdouble, true, false, 0xffffffffffffae72ULL)); 950} 951 952#ifdef GTEST_HAS_DEATH_TEST 953#ifndef NDEBUG 954TEST(APFloatTest, SemanticsDeath) { 955 EXPECT_DEATH(APFloat(APFloat::IEEEsingle, 0.0f).convertToDouble(), "Float semantics are not IEEEdouble"); 956 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, 0.0 ).convertToFloat(), "Float semantics are not IEEEsingle"); 957} 958 959TEST(APFloatTest, StringDecimalDeath) { 960 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ""), "Invalid string length"); 961 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+"), "String has no digits"); 962 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-"), "String has no digits"); 963 964 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("\0", 1)), "Invalid character in significand"); 965 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\0", 2)), "Invalid character in significand"); 966 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02", 3)), "Invalid character in significand"); 967 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02e1", 5)), "Invalid character in significand"); 968 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e\0", 3)), "Invalid character in exponent"); 969 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\0", 4)), "Invalid character in exponent"); 970 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\02", 5)), "Invalid character in exponent"); 971 972 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0f"), "Invalid character in significand"); 973 974 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".."), "String contains multiple dots"); 975 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "..0"), "String contains multiple dots"); 976 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0.0"), "String contains multiple dots"); 977} 978 979TEST(APFloatTest, StringDecimalSignificandDeath) { 980 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "."), "Significand has no digits"); 981 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+."), "Significand has no digits"); 982 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-."), "Significand has no digits"); 983 984 985 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "e"), "Significand has no digits"); 986 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+e"), "Significand has no digits"); 987 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-e"), "Significand has no digits"); 988 989 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "e1"), "Significand has no digits"); 990 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+e1"), "Significand has no digits"); 991 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-e1"), "Significand has no digits"); 992 993 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".e1"), "Significand has no digits"); 994 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.e1"), "Significand has no digits"); 995 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.e1"), "Significand has no digits"); 996 997 998 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".e"), "Significand has no digits"); 999 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.e"), "Significand has no digits"); 1000 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.e"), "Significand has no digits"); 1001} 1002 1003TEST(APFloatTest, StringDecimalExponentDeath) { 1004 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e"), "Exponent has no digits"); 1005 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+1e"), "Exponent has no digits"); 1006 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-1e"), "Exponent has no digits"); 1007 1008 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.e"), "Exponent has no digits"); 1009 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+1.e"), "Exponent has no digits"); 1010 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-1.e"), "Exponent has no digits"); 1011 1012 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e"), "Exponent has no digits"); 1013 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.1e"), "Exponent has no digits"); 1014 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.1e"), "Exponent has no digits"); 1015 1016 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.1e"), "Exponent has no digits"); 1017 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+1.1e"), "Exponent has no digits"); 1018 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-1.1e"), "Exponent has no digits"); 1019 1020 1021 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e+"), "Exponent has no digits"); 1022 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e-"), "Exponent has no digits"); 1023 1024 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e"), "Exponent has no digits"); 1025 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e+"), "Exponent has no digits"); 1026 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e-"), "Exponent has no digits"); 1027 1028 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e"), "Exponent has no digits"); 1029 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e+"), "Exponent has no digits"); 1030 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e-"), "Exponent has no digits"); 1031} 1032 1033TEST(APFloatTest, StringHexadecimalDeath) { 1034 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x"), "Invalid string"); 1035 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x"), "Invalid string"); 1036 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x"), "Invalid string"); 1037 1038 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x0"), "Hex strings require an exponent"); 1039 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0"), "Hex strings require an exponent"); 1040 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0"), "Hex strings require an exponent"); 1041 1042 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x0."), "Hex strings require an exponent"); 1043 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0."), "Hex strings require an exponent"); 1044 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0."), "Hex strings require an exponent"); 1045 1046 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.0"), "Hex strings require an exponent"); 1047 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.0"), "Hex strings require an exponent"); 1048 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.0"), "Hex strings require an exponent"); 1049 1050 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x0.0"), "Hex strings require an exponent"); 1051 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0.0"), "Hex strings require an exponent"); 1052 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0.0"), "Hex strings require an exponent"); 1053 1054 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x\0", 3)), "Invalid character in significand"); 1055 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\0", 4)), "Invalid character in significand"); 1056 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02", 5)), "Invalid character in significand"); 1057 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02p1", 7)), "Invalid character in significand"); 1058 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p\0", 5)), "Invalid character in exponent"); 1059 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\0", 6)), "Invalid character in exponent"); 1060 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\02", 7)), "Invalid character in exponent"); 1061 1062 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p0f"), "Invalid character in exponent"); 1063 1064 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x..p1"), "String contains multiple dots"); 1065 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x..0p1"), "String contains multiple dots"); 1066 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.0.0p1"), "String contains multiple dots"); 1067} 1068 1069TEST(APFloatTest, StringHexadecimalSignificandDeath) { 1070 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x."), "Significand has no digits"); 1071 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x."), "Significand has no digits"); 1072 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x."), "Significand has no digits"); 1073 1074 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0xp"), "Significand has no digits"); 1075 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp"), "Significand has no digits"); 1076 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp"), "Significand has no digits"); 1077 1078 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0xp+"), "Significand has no digits"); 1079 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp+"), "Significand has no digits"); 1080 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp+"), "Significand has no digits"); 1081 1082 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0xp-"), "Significand has no digits"); 1083 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp-"), "Significand has no digits"); 1084 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp-"), "Significand has no digits"); 1085 1086 1087 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.p"), "Significand has no digits"); 1088 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p"), "Significand has no digits"); 1089 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p"), "Significand has no digits"); 1090 1091 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.p+"), "Significand has no digits"); 1092 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p+"), "Significand has no digits"); 1093 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p+"), "Significand has no digits"); 1094 1095 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.p-"), "Significand has no digits"); 1096 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p-"), "Significand has no digits"); 1097 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p-"), "Significand has no digits"); 1098} 1099 1100TEST(APFloatTest, StringHexadecimalExponentDeath) { 1101 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p"), "Exponent has no digits"); 1102 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p"), "Exponent has no digits"); 1103 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p"), "Exponent has no digits"); 1104 1105 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p+"), "Exponent has no digits"); 1106 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p+"), "Exponent has no digits"); 1107 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p+"), "Exponent has no digits"); 1108 1109 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p-"), "Exponent has no digits"); 1110 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p-"), "Exponent has no digits"); 1111 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p-"), "Exponent has no digits"); 1112 1113 1114 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.p"), "Exponent has no digits"); 1115 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p"), "Exponent has no digits"); 1116 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p"), "Exponent has no digits"); 1117 1118 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.p+"), "Exponent has no digits"); 1119 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p+"), "Exponent has no digits"); 1120 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p+"), "Exponent has no digits"); 1121 1122 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.p-"), "Exponent has no digits"); 1123 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p-"), "Exponent has no digits"); 1124 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p-"), "Exponent has no digits"); 1125 1126 1127 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.1p"), "Exponent has no digits"); 1128 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p"), "Exponent has no digits"); 1129 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p"), "Exponent has no digits"); 1130 1131 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.1p+"), "Exponent has no digits"); 1132 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p+"), "Exponent has no digits"); 1133 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p+"), "Exponent has no digits"); 1134 1135 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.1p-"), "Exponent has no digits"); 1136 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p-"), "Exponent has no digits"); 1137 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p-"), "Exponent has no digits"); 1138 1139 1140 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.1p"), "Exponent has no digits"); 1141 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p"), "Exponent has no digits"); 1142 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p"), "Exponent has no digits"); 1143 1144 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.1p+"), "Exponent has no digits"); 1145 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p+"), "Exponent has no digits"); 1146 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p+"), "Exponent has no digits"); 1147 1148 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.1p-"), "Exponent has no digits"); 1149 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p-"), "Exponent has no digits"); 1150 EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p-"), "Exponent has no digits"); 1151} 1152#endif 1153#endif 1154 1155TEST(APFloatTest, exactInverse) { 1156 APFloat inv(0.0f); 1157 1158 // Trivial operation. 1159 EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv)); 1160 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5))); 1161 EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv)); 1162 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f))); 1163 EXPECT_TRUE(APFloat(APFloat::IEEEquad, "2.0").getExactInverse(&inv)); 1164 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad, "0.5"))); 1165 EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble, "2.0").getExactInverse(&inv)); 1166 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble, "0.5"))); 1167 EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended, "2.0").getExactInverse(&inv)); 1168 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended, "0.5"))); 1169 1170 // FLT_MIN 1171 EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv)); 1172 EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f))); 1173 1174 // Large float, inverse is a denormal. 1175 EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(0)); 1176 // Zero 1177 EXPECT_FALSE(APFloat(0.0).getExactInverse(0)); 1178 // Denormalized float 1179 EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(0)); 1180} 1181 1182TEST(APFloatTest, roundToIntegral) { 1183 APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble)), P(0.0); 1184 1185 P = T; 1186 P.roundToIntegral(APFloat::rmTowardZero); 1187 EXPECT_EQ(-0.0, P.convertToDouble()); 1188 P = T; 1189 P.roundToIntegral(APFloat::rmTowardNegative); 1190 EXPECT_EQ(-1.0, P.convertToDouble()); 1191 P = T; 1192 P.roundToIntegral(APFloat::rmTowardPositive); 1193 EXPECT_EQ(-0.0, P.convertToDouble()); 1194 P = T; 1195 P.roundToIntegral(APFloat::rmNearestTiesToEven); 1196 EXPECT_EQ(-0.0, P.convertToDouble()); 1197 1198 P = S; 1199 P.roundToIntegral(APFloat::rmTowardZero); 1200 EXPECT_EQ(3.0, P.convertToDouble()); 1201 P = S; 1202 P.roundToIntegral(APFloat::rmTowardNegative); 1203 EXPECT_EQ(3.0, P.convertToDouble()); 1204 P = S; 1205 P.roundToIntegral(APFloat::rmTowardPositive); 1206 EXPECT_EQ(4.0, P.convertToDouble()); 1207 P = S; 1208 P.roundToIntegral(APFloat::rmNearestTiesToEven); 1209 EXPECT_EQ(3.0, P.convertToDouble()); 1210 1211 P = R; 1212 P.roundToIntegral(APFloat::rmTowardZero); 1213 EXPECT_EQ(R.convertToDouble(), P.convertToDouble()); 1214 P = R; 1215 P.roundToIntegral(APFloat::rmTowardNegative); 1216 EXPECT_EQ(R.convertToDouble(), P.convertToDouble()); 1217 P = R; 1218 P.roundToIntegral(APFloat::rmTowardPositive); 1219 EXPECT_EQ(R.convertToDouble(), P.convertToDouble()); 1220 P = R; 1221 P.roundToIntegral(APFloat::rmNearestTiesToEven); 1222 EXPECT_EQ(R.convertToDouble(), P.convertToDouble()); 1223 1224 P = APFloat::getZero(APFloat::IEEEdouble); 1225 P.roundToIntegral(APFloat::rmTowardZero); 1226 EXPECT_EQ(0.0, P.convertToDouble()); 1227 P = APFloat::getZero(APFloat::IEEEdouble, true); 1228 P.roundToIntegral(APFloat::rmTowardZero); 1229 EXPECT_EQ(-0.0, P.convertToDouble()); 1230 P = APFloat::getNaN(APFloat::IEEEdouble); 1231 P.roundToIntegral(APFloat::rmTowardZero); 1232 EXPECT_TRUE(IsNAN(P.convertToDouble())); 1233 P = APFloat::getInf(APFloat::IEEEdouble); 1234 P.roundToIntegral(APFloat::rmTowardZero); 1235 EXPECT_TRUE(IsInf(P.convertToDouble()) && P.convertToDouble() > 0.0); 1236 P = APFloat::getInf(APFloat::IEEEdouble, true); 1237 P.roundToIntegral(APFloat::rmTowardZero); 1238 EXPECT_TRUE(IsInf(P.convertToDouble()) && P.convertToDouble() < 0.0); 1239 1240} 1241 1242TEST(APFloatTest, getLargest) { 1243 EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle).convertToFloat()); 1244 EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble).convertToDouble()); 1245} 1246 1247TEST(APFloatTest, getSmallest) { 1248 APFloat test = APFloat::getSmallest(APFloat::IEEEsingle, false); 1249 APFloat expected = APFloat(APFloat::IEEEsingle, "0x0.000002p-126"); 1250 EXPECT_FALSE(test.isNegative()); 1251 EXPECT_TRUE(test.isFiniteNonZero()); 1252 EXPECT_TRUE(test.isDenormal()); 1253 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1254 1255 test = APFloat::getSmallest(APFloat::IEEEsingle, true); 1256 expected = APFloat(APFloat::IEEEsingle, "-0x0.000002p-126"); 1257 EXPECT_TRUE(test.isNegative()); 1258 EXPECT_TRUE(test.isFiniteNonZero()); 1259 EXPECT_TRUE(test.isDenormal()); 1260 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1261 1262 test = APFloat::getSmallest(APFloat::IEEEquad, false); 1263 expected = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382"); 1264 EXPECT_FALSE(test.isNegative()); 1265 EXPECT_TRUE(test.isFiniteNonZero()); 1266 EXPECT_TRUE(test.isDenormal()); 1267 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1268 1269 test = APFloat::getSmallest(APFloat::IEEEquad, true); 1270 expected = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382"); 1271 EXPECT_TRUE(test.isNegative()); 1272 EXPECT_TRUE(test.isFiniteNonZero()); 1273 EXPECT_TRUE(test.isDenormal()); 1274 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1275} 1276 1277TEST(APFloatTest, getSmallestNormalized) { 1278 APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle, false); 1279 APFloat expected = APFloat(APFloat::IEEEsingle, "0x1p-126"); 1280 EXPECT_FALSE(test.isNegative()); 1281 EXPECT_TRUE(test.isFiniteNonZero()); 1282 EXPECT_FALSE(test.isDenormal()); 1283 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1284 1285 test = APFloat::getSmallestNormalized(APFloat::IEEEsingle, true); 1286 expected = APFloat(APFloat::IEEEsingle, "-0x1p-126"); 1287 EXPECT_TRUE(test.isNegative()); 1288 EXPECT_TRUE(test.isFiniteNonZero()); 1289 EXPECT_FALSE(test.isDenormal()); 1290 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1291 1292 test = APFloat::getSmallestNormalized(APFloat::IEEEquad, false); 1293 expected = APFloat(APFloat::IEEEquad, "0x1p-16382"); 1294 EXPECT_FALSE(test.isNegative()); 1295 EXPECT_TRUE(test.isFiniteNonZero()); 1296 EXPECT_FALSE(test.isDenormal()); 1297 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1298 1299 test = APFloat::getSmallestNormalized(APFloat::IEEEquad, true); 1300 expected = APFloat(APFloat::IEEEquad, "-0x1p-16382"); 1301 EXPECT_TRUE(test.isNegative()); 1302 EXPECT_TRUE(test.isFiniteNonZero()); 1303 EXPECT_FALSE(test.isDenormal()); 1304 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1305} 1306 1307TEST(APFloatTest, getZero) { 1308 struct { 1309 const fltSemantics *semantics; 1310 const bool sign; 1311 const unsigned long long bitPattern[2]; 1312 const unsigned bitPatternLength; 1313 } const GetZeroTest[] = { 1314 { &APFloat::IEEEhalf, false, {0, 0}, 1}, 1315 { &APFloat::IEEEhalf, true, {0x8000ULL, 0}, 1}, 1316 { &APFloat::IEEEsingle, false, {0, 0}, 1}, 1317 { &APFloat::IEEEsingle, true, {0x80000000ULL, 0}, 1}, 1318 { &APFloat::IEEEdouble, false, {0, 0}, 1}, 1319 { &APFloat::IEEEdouble, true, {0x8000000000000000ULL, 0}, 1}, 1320 { &APFloat::IEEEquad, false, {0, 0}, 2}, 1321 { &APFloat::IEEEquad, true, {0, 0x8000000000000000ULL}, 2}, 1322 { &APFloat::PPCDoubleDouble, false, {0, 0}, 2}, 1323 { &APFloat::PPCDoubleDouble, true, {0x8000000000000000ULL, 0}, 2}, 1324 { &APFloat::x87DoubleExtended, false, {0, 0}, 2}, 1325 { &APFloat::x87DoubleExtended, true, {0, 0x8000ULL}, 2}, 1326 }; 1327 const unsigned NumGetZeroTests = 12; 1328 for (unsigned i = 0; i < NumGetZeroTests; ++i) { 1329 APFloat test = APFloat::getZero(*GetZeroTest[i].semantics, 1330 GetZeroTest[i].sign); 1331 const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0"; 1332 APFloat expected = APFloat(*GetZeroTest[i].semantics, 1333 pattern); 1334 EXPECT_TRUE(test.isZero()); 1335 EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative()); 1336 EXPECT_TRUE(test.bitwiseIsEqual(expected)); 1337 for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) { 1338 EXPECT_EQ(GetZeroTest[i].bitPattern[j], 1339 test.bitcastToAPInt().getRawData()[j]); 1340 } 1341 } 1342} 1343 1344TEST(APFloatTest, convert) { 1345 bool losesInfo; 1346 APFloat test(APFloat::IEEEdouble, "1.0"); 1347 test.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &losesInfo); 1348 EXPECT_EQ(1.0f, test.convertToFloat()); 1349 EXPECT_FALSE(losesInfo); 1350 1351 test = APFloat(APFloat::x87DoubleExtended, "0x1p-53"); 1352 test.add(APFloat(APFloat::x87DoubleExtended, "1.0"), APFloat::rmNearestTiesToEven); 1353 test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo); 1354 EXPECT_EQ(1.0, test.convertToDouble()); 1355 EXPECT_TRUE(losesInfo); 1356 1357 test = APFloat(APFloat::IEEEquad, "0x1p-53"); 1358 test.add(APFloat(APFloat::IEEEquad, "1.0"), APFloat::rmNearestTiesToEven); 1359 test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo); 1360 EXPECT_EQ(1.0, test.convertToDouble()); 1361 EXPECT_TRUE(losesInfo); 1362 1363 test = APFloat(APFloat::x87DoubleExtended, "0xf.fffffffp+28"); 1364 test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo); 1365 EXPECT_EQ(4294967295.0, test.convertToDouble()); 1366 EXPECT_FALSE(losesInfo); 1367 1368 test = APFloat::getSNaN(APFloat::IEEEsingle); 1369 APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended); 1370 test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven, 1371 &losesInfo); 1372 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN)); 1373 EXPECT_FALSE(losesInfo); 1374 1375 test = APFloat::getQNaN(APFloat::IEEEsingle); 1376 APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended); 1377 test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven, 1378 &losesInfo); 1379 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN)); 1380 EXPECT_FALSE(losesInfo); 1381 1382 test = APFloat::getSNaN(APFloat::x87DoubleExtended); 1383 test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven, 1384 &losesInfo); 1385 EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN)); 1386 EXPECT_FALSE(losesInfo); 1387 1388 test = APFloat::getQNaN(APFloat::x87DoubleExtended); 1389 test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven, 1390 &losesInfo); 1391 EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN)); 1392 EXPECT_FALSE(losesInfo); 1393} 1394 1395TEST(APFloatTest, PPCDoubleDouble) { 1396 APFloat test(APFloat::PPCDoubleDouble, "1.0"); 1397 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]); 1398 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]); 1399 1400 test.divide(APFloat(APFloat::PPCDoubleDouble, "3.0"), APFloat::rmNearestTiesToEven); 1401 EXPECT_EQ(0x3fd5555555555555ull, test.bitcastToAPInt().getRawData()[0]); 1402 EXPECT_EQ(0x3c75555555555556ull, test.bitcastToAPInt().getRawData()[1]); 1403 1404 // LDBL_MAX 1405 test = APFloat(APFloat::PPCDoubleDouble, "1.79769313486231580793728971405301e+308"); 1406 EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]); 1407 EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]); 1408 1409 // LDBL_MIN 1410 test = APFloat(APFloat::PPCDoubleDouble, "2.00416836000897277799610805135016e-292"); 1411 EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]); 1412 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]); 1413 1414 test = APFloat(APFloat::PPCDoubleDouble, "1.0"); 1415 test.add(APFloat(APFloat::PPCDoubleDouble, "0x1p-105"), APFloat::rmNearestTiesToEven); 1416 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]); 1417 EXPECT_EQ(0x3960000000000000ull, test.bitcastToAPInt().getRawData()[1]); 1418 1419 test = APFloat(APFloat::PPCDoubleDouble, "1.0"); 1420 test.add(APFloat(APFloat::PPCDoubleDouble, "0x1p-106"), APFloat::rmNearestTiesToEven); 1421 EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]); 1422#if 0 // XFAIL 1423 // This is what we would expect with a true double-double implementation 1424 EXPECT_EQ(0x3950000000000000ull, test.bitcastToAPInt().getRawData()[1]); 1425#else 1426 // This is what we get with our 106-bit mantissa approximation 1427 EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]); 1428#endif 1429} 1430 1431TEST(APFloatTest, isNegative) { 1432 APFloat t(APFloat::IEEEsingle, "0x1p+0"); 1433 EXPECT_FALSE(t.isNegative()); 1434 t = APFloat(APFloat::IEEEsingle, "-0x1p+0"); 1435 EXPECT_TRUE(t.isNegative()); 1436 1437 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNegative()); 1438 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle, true).isNegative()); 1439 1440 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNegative()); 1441 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle, true).isNegative()); 1442 1443 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isNegative()); 1444 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle, true).isNegative()); 1445 1446 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNegative()); 1447 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true).isNegative()); 1448} 1449 1450TEST(APFloatTest, isNormal) { 1451 APFloat t(APFloat::IEEEsingle, "0x1p+0"); 1452 EXPECT_TRUE(t.isNormal()); 1453 1454 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNormal()); 1455 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNormal()); 1456 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isNormal()); 1457 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNormal()); 1458 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isNormal()); 1459} 1460 1461TEST(APFloatTest, isFinite) { 1462 APFloat t(APFloat::IEEEsingle, "0x1p+0"); 1463 EXPECT_TRUE(t.isFinite()); 1464 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isFinite()); 1465 EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle, false).isFinite()); 1466 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isFinite()); 1467 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isFinite()); 1468 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p-149").isFinite()); 1469} 1470 1471TEST(APFloatTest, isInfinity) { 1472 APFloat t(APFloat::IEEEsingle, "0x1p+0"); 1473 EXPECT_FALSE(t.isInfinity()); 1474 EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle, false).isInfinity()); 1475 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isInfinity()); 1476 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isInfinity()); 1477 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isInfinity()); 1478 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isInfinity()); 1479} 1480 1481TEST(APFloatTest, isNaN) { 1482 APFloat t(APFloat::IEEEsingle, "0x1p+0"); 1483 EXPECT_FALSE(t.isNaN()); 1484 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNaN()); 1485 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNaN()); 1486 EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle, false).isNaN()); 1487 EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNaN()); 1488 EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isNaN()); 1489} 1490 1491TEST(APFloatTest, isFiniteNonZero) { 1492 // Test positive/negative normal value. 1493 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p+0").isFiniteNonZero()); 1494 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "-0x1p+0").isFiniteNonZero()); 1495 1496 // Test positive/negative denormal value. 1497 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p-149").isFiniteNonZero()); 1498 EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "-0x1p-149").isFiniteNonZero()); 1499 1500 // Test +/- Infinity. 1501 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isFiniteNonZero()); 1502 EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, true).isFiniteNonZero()); 1503 1504 // Test +/- Zero. 1505 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isFiniteNonZero()); 1506 EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, true).isFiniteNonZero()); 1507 1508 // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in 1509 // this instance. 1510 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isFiniteNonZero()); 1511 EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, true).isFiniteNonZero()); 1512 1513 // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in 1514 // this instance. 1515 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isFiniteNonZero()); 1516 EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, true).isFiniteNonZero()); 1517} 1518 1519TEST(APFloatTest, add) { 1520 // Test Special Cases against each other and normal values. 1521 1522 // TODOS/NOTES: 1523 // 1. Since we perform only default exception handling all operations with 1524 // signaling NaNs should have a result that is a quiet NaN. Currently they 1525 // return sNaN. 1526 // 2. It seems that add(-x, NaN) = -NaN but add(NaN, -x) = NaN. This is an 1527 // inconsistency that should be looked into. IEEE-754R specifies that the 1528 // interpretation of the sign of NaN is unspecified. We should always have NaN 1529 // be positive since that is one less thing for the compiler to deal with. 1530 1531 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false); 1532 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true); 1533 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false); 1534 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true); 1535 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false); 1536 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false); 1537 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0"); 1538 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0"); 1539 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false); 1540 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true); 1541 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false); 1542 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true); 1543 APFloat PSmallestNormalized = 1544 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false); 1545 APFloat MSmallestNormalized = 1546 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true); 1547 1548 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact; 1549 1550 const unsigned NumTests = 169; 1551 struct { 1552 APFloat x; 1553 APFloat y; 1554 const char *result; 1555 int status; 1556 int category; 1557 } SpecialCaseTests[NumTests] = { 1558 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1559 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1560 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 1561 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 1562 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1563#if 0 1564 // See Note 1. 1565 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1566#endif 1567 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1568 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1569 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1570 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1571 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1572 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1573 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 1574 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 1575 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1576 { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1577 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1578 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1579 // See Note 2. 1580 { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 1581#if 0 1582 // See Note 1. 1583 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1584#endif 1585 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1586 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1587 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1588 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1589 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1590 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1591 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1592 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1593 { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1594 { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1595 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1596 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1597 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1598#if 0 1599 // See Note 1. 1600 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1601#endif 1602 { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1603 { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1604 { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1605 { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1606 { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1607 { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1608 { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1609 { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1610 { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1611 { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1612 { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1613 { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 1614 // See Note 2. 1615 { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 1616#if 0 1617 // See Note 1. 1618 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1619#endif 1620 { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1621 { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1622 { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1623 { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1624 { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1625 { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1626 { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1627 { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1628 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 1629 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, 1630 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 1631 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN }, 1632 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1633#if 0 1634 // See Note 1. 1635 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1636#endif 1637 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1638 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1639 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1640 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1641 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1642 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1643 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 1644 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 1645#if 0 1646 // See Note 1. 1647 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1648 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1649 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1650 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1651 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1652 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1653 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1654 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1655 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1656 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1657 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1658 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1659 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1660 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1661#endif 1662 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1663 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1664 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1665 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1666 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1667#if 0 1668 // See Note 1. 1669 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1670#endif 1671 { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal }, 1672 { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1673 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1674 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1675 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1676 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1677 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1678 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1679 { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1680 { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1681 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1682 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1683 // See Note 2. 1684 { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 1685#if 0 1686 // See Note 1. 1687 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1688#endif 1689 { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1690 { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal }, 1691 { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1692 { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1693 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1694 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1695 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1696 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1697 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1698 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1699 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1700 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1701 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1702#if 0 1703 // See Note 1. 1704 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1705#endif 1706 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1707 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1708 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 1709 { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1710 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1711 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1712 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1713 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1714 { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1715 { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1716 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1717 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1718 // See Note 2. 1719 { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 1720#if 0 1721 // See Note 1. 1722 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1723#endif 1724 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1725 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1726 { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1727 { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 1728 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1729 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1730 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1731 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1732 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1733 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1734 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1735 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1736 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1737#if 0 1738 // See Note 1. 1739 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1740#endif 1741 { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1742 { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1743 { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1744 { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1745 { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal }, 1746 { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1747 { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 1748 { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 1749 { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1750 { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1751 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1752 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1753 // See Note 2. 1754 { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 1755#if 0 1756 // See Note 1. 1757 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1758#endif 1759 { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1760 { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1761 { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1762 { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1763 { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1764 { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal }, 1765 { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 1766 { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 1767 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1768 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1769 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1770 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1771 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1772#if 0 1773// See Note 1. 1774 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1775#endif 1776 { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1777 { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1778 { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1779 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1780 { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 1781 { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 1782 { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal }, 1783 { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1784 { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1785 { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1786 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1787 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1788 // See Note 2. 1789 { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 1790#if 0 1791 // See Note 1. 1792 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1793#endif 1794 { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1795 { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1796 { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1797 { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1798 { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 1799 { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 1800 { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1801 { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal } 1802 }; 1803 1804 for (size_t i = 0; i < NumTests; ++i) { 1805 APFloat x(SpecialCaseTests[i].x); 1806 APFloat y(SpecialCaseTests[i].y); 1807 APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven); 1808 1809 APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result); 1810 1811 EXPECT_TRUE(result.bitwiseIsEqual(x)); 1812 EXPECT_TRUE((int)status == SpecialCaseTests[i].status); 1813 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category); 1814 } 1815} 1816 1817TEST(APFloatTest, subtract) { 1818 // Test Special Cases against each other and normal values. 1819 1820 // TODOS/NOTES: 1821 // 1. Since we perform only default exception handling all operations with 1822 // signaling NaNs should have a result that is a quiet NaN. Currently they 1823 // return sNaN. 1824 // 2. It seems that sub(-x, NaN) = -NaN but sub(NaN, -x) = NaN. This is an 1825 // inconsistency that should be looked into. IEEE-754R specifies that the 1826 // interpretation of the sign of NaN is unspecified. We should always have NaN 1827 // be positive since that is one less thing for the compiler to deal with. 1828 1829 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false); 1830 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true); 1831 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false); 1832 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true); 1833 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false); 1834 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false); 1835 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0"); 1836 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0"); 1837 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false); 1838 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true); 1839 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false); 1840 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true); 1841 APFloat PSmallestNormalized = 1842 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false); 1843 APFloat MSmallestNormalized = 1844 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true); 1845 1846 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact; 1847 1848 const unsigned NumTests = 169; 1849 struct { 1850 APFloat x; 1851 APFloat y; 1852 const char *result; 1853 int status; 1854 int category; 1855 } SpecialCaseTests[NumTests] = { 1856 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1857 { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1858 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 1859 { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 1860 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1861#if 0 1862// See Note 1. 1863 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1864#endif 1865 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1866 { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1867 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1868 { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1869 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1870 { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 1871 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 1872 { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 1873 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1874 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1875 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1876 { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1877 // See Note 2. 1878 { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 1879#if 0 1880// See Note 1. 1881 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1882#endif 1883 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1884 { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1885 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1886 { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1887 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1888 { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1889 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1890 { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1891 { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1892 { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1893 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1894 { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1895 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1896#if 0 1897// See Note 1. 1898 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1899#endif 1900 { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1901 { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1902 { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1903 { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1904 { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1905 { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1906 { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1907 { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1908 { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1909 { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1910 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 1911 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1912 // See Note 2. 1913 { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 1914#if 0 1915// See Note 1. 1916 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1917#endif 1918 { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1919 { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1920 { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1921 { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1922 { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1923 { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 1924 { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1925 { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 1926 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 1927 { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN }, 1928 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 1929 { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN }, 1930 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1931#if 0 1932// See Note 1. 1933 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1934#endif 1935 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1936 { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1937 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1938 { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1939 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1940 { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 1941 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 1942 { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 1943#if 0 1944// See Note 1. 1945 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1946 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1947 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1948 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1949 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1950 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1951 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1952 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1953 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1954 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1955 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1956 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1957 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1958 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1959#endif 1960 { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1961 { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1962 { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1963 { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1964 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 1965#if 0 1966// See Note 1. 1967 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1968#endif 1969 { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1970 { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal }, 1971 { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1972 { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1973 { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1974 { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1975 { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1976 { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1977 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1978 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1979 { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1980 { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 1981 // See Note 2. 1982 { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 1983#if 0 1984// See Note 1. 1985 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 1986#endif 1987 { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal }, 1988 { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 1989 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1990 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 1991 { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1992 { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1993 { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1994 { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 1995 { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 1996 { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 1997 { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1998 { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 1999 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2000#if 0 2001// See Note 1. 2002 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2003#endif 2004 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2005 { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2006 { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2007 { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2008 { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2009 { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2010 { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2011 { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2012 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2013 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2014 { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2015 { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2016 // See Note 2. 2017 { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2018#if 0 2019// See Note 1. 2020 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2021#endif 2022 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2023 { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2024 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2025 { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2026 { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2027 { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2028 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2029 { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2030 { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2031 { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2032 { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2033 { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2034 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2035#if 0 2036// See Note 1. 2037 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2038#endif 2039 { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2040 { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2041 { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2042 { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2043 { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2044 { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal }, 2045 { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2046 { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2047 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2048 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2049 { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2050 { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2051 // See Note 2. 2052 { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2053#if 0 2054// See Note 1. 2055 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2056#endif 2057 { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2058 { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2059 { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2060 { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2061 { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal }, 2062 { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2063 { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2064 { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2065 { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2066 { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2067 { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2068 { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2069 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2070#if 0 2071// See Note 1. 2072 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2073#endif 2074 { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2075 { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2076 { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2077 { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2078 { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2079 { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2080 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2081 { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal }, 2082 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2083 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2084 { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2085 { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2086 // See Note 2. 2087 { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2088#if 0 2089// See Note 1. 2090 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2091#endif 2092 { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2093 { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal }, 2094 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2095 { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal }, 2096 { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal }, 2097 { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal }, 2098 { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }, 2099 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero } 2100 }; 2101 2102 for (size_t i = 0; i < NumTests; ++i) { 2103 APFloat x(SpecialCaseTests[i].x); 2104 APFloat y(SpecialCaseTests[i].y); 2105 APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven); 2106 2107 APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result); 2108 2109 EXPECT_TRUE(result.bitwiseIsEqual(x)); 2110 EXPECT_TRUE((int)status == SpecialCaseTests[i].status); 2111 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category); 2112 } 2113} 2114 2115TEST(APFloatTest, multiply) { 2116 // Test Special Cases against each other and normal values. 2117 2118 // TODOS/NOTES: 2119 // 1. Since we perform only default exception handling all operations with 2120 // signaling NaNs should have a result that is a quiet NaN. Currently they 2121 // return sNaN. 2122 // 2. It seems that multiply(-x, NaN) = multiply(NaN, -x) = -NaN. IEEE-754R 2123 // leaves the meaning of the sign of NaNs as unspecified. To simplify things, 2124 // we should just assume that NaN is always positive. I will fix this. 2125 2126 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false); 2127 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true); 2128 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false); 2129 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true); 2130 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false); 2131 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false); 2132 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0"); 2133 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0"); 2134 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false); 2135 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true); 2136 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false); 2137 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true); 2138 APFloat PSmallestNormalized = 2139 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false); 2140 APFloat MSmallestNormalized = 2141 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true); 2142 2143 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact; 2144 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact; 2145 2146 const unsigned NumTests = 169; 2147 struct { 2148 APFloat x; 2149 APFloat y; 2150 const char *result; 2151 int status; 2152 int category; 2153 } SpecialCaseTests[NumTests] = { 2154 { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2155 { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2156 { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2157 { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2158 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2159#if 0 2160// See Note 1. 2161 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2162#endif 2163 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2164 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2165 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2166 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2167 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2168 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2169 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2170 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2171 { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2172 { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2173 { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2174 { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2175 // See Note 2. 2176 { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2177#if 0 2178// See Note 1. 2179 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2180#endif 2181 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2182 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2183 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2184 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2185 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2186 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2187 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2188 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2189 { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2190 { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2191 { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2192 { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2193 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2194#if 0 2195// See Note 1. 2196 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2197#endif 2198 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2199 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2200 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2201 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2202 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2203 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2204 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2205 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2206 { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2207 { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2208 { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2209 { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2210 // See Note 2. 2211 { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2212#if 0 2213// See Note 1. 2214 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2215#endif 2216 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2217 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2218 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2219 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2220 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2221 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2222 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2223 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2224 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2225 // See Note 2. 2226 { QNaN, MInf, "-nan", APFloat::opOK, APFloat::fcNaN }, 2227 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2228 // See Note 2. 2229 { QNaN, MZero, "-nan", APFloat::opOK, APFloat::fcNaN }, 2230 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2231#if 0 2232// See Note 1. 2233 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2234#endif 2235 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2236 // See Note 2. 2237 { QNaN, MNormalValue, "-nan", APFloat::opOK, APFloat::fcNaN }, 2238 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2239 // See Note 2. 2240 { QNaN, MLargestValue, "-nan", APFloat::opOK, APFloat::fcNaN }, 2241 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2242 // See Note 2. 2243 { QNaN, MSmallestValue, "-nan", APFloat::opOK, APFloat::fcNaN }, 2244 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2245 // See Note 2. 2246 { QNaN, MSmallestNormalized, "-nan", APFloat::opOK, APFloat::fcNaN }, 2247#if 0 2248// See Note 1. 2249 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2250 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2251 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2252 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2253 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2254 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2255 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2256 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2257 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2258 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2259 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2260 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2261 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2262 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2263#endif 2264 { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2265 { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2266 { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2267 { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2268 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2269#if 0 2270// See Note 1. 2271 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2272#endif 2273 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2274 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2275 { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2276 { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2277 { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2278 { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2279 { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2280 { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2281 { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2282 { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2283 { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2284 { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2285 // See Note 2. 2286 { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2287#if 0 2288// See Note 1. 2289 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2290#endif 2291 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2292 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2293 { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2294 { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2295 { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2296 { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2297 { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2298 { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2299 { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2300 { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2301 { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2302 { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2303 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2304#if 0 2305// See Note 1. 2306 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2307#endif 2308 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2309 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2310 { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2311 { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2312 { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2313 { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2314 { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2315 { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2316 { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2317 { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2318 { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2319 { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2320 // See Note 2. 2321 { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2322#if 0 2323// See Note 1. 2324 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2325#endif 2326 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2327 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2328 { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2329 { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2330 { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2331 { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2332 { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2333 { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2334 { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2335 { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2336 { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2337 { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2338 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2339#if 0 2340// See Note 1. 2341 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2342#endif 2343 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2344 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2345 { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2346 { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2347 { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2348 { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2349 { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2350 { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2351 { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2352 { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2353 { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2354 { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2355 // See Note 2. 2356 { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2357#if 0 2358// See Note 1. 2359 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2360#endif 2361 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2362 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2363 { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2364 { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal }, 2365 { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2366 { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2367 { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2368 { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2369 { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2370 { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2371 { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2372 { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2373 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2374#if 0 2375// See Note 1. 2376 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2377#endif 2378 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2379 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2380 { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2381 { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2382 { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2383 { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2384 { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2385 { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2386 { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2387 { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity }, 2388 { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2389 { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2390 // See Note 2. 2391 { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2392#if 0 2393// See Note 1. 2394 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2395#endif 2396 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2397 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2398 { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2399 { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal }, 2400 { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2401 { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2402 { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2403 { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero } 2404 }; 2405 2406 for (size_t i = 0; i < NumTests; ++i) { 2407 APFloat x(SpecialCaseTests[i].x); 2408 APFloat y(SpecialCaseTests[i].y); 2409 APFloat::opStatus status = x.multiply(y, APFloat::rmNearestTiesToEven); 2410 2411 APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result); 2412 2413 EXPECT_TRUE(result.bitwiseIsEqual(x)); 2414 EXPECT_TRUE((int)status == SpecialCaseTests[i].status); 2415 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category); 2416 } 2417} 2418 2419TEST(APFloatTest, divide) { 2420 // Test Special Cases against each other and normal values. 2421 2422 // TODOS/NOTES: 2423 // 1. Since we perform only default exception handling all operations with 2424 // signaling NaNs should have a result that is a quiet NaN. Currently they 2425 // return sNaN. 2426 // 2. It seems that divide(-x, NaN) = divide(NaN, -x) = -NaN. IEEE-754R 2427 // leaves the meaning of the sign of NaNs as unspecified. To simplify things, 2428 // we should just assume that NaN is always positive. I will fix this. 2429 2430 APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false); 2431 APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true); 2432 APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false); 2433 APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true); 2434 APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false); 2435 APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false); 2436 APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0"); 2437 APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0"); 2438 APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false); 2439 APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true); 2440 APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false); 2441 APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true); 2442 APFloat PSmallestNormalized = 2443 APFloat::getSmallestNormalized(APFloat::IEEEsingle, false); 2444 APFloat MSmallestNormalized = 2445 APFloat::getSmallestNormalized(APFloat::IEEEsingle, true); 2446 2447 const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact; 2448 const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact; 2449 2450 const unsigned NumTests = 169; 2451 struct { 2452 APFloat x; 2453 APFloat y; 2454 const char *result; 2455 int status; 2456 int category; 2457 } SpecialCaseTests[NumTests] = { 2458 { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2459 { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2460 { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 2461 { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2462 { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2463#if 0 2464// See Note 1. 2465 { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2466#endif 2467 { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2468 { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2469 { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2470 { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2471 { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2472 { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2473 { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2474 { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2475 { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2476 { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2477 { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2478 { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity }, 2479 // See Note 2. 2480 { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2481#if 0 2482// See Note 1. 2483 { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2484#endif 2485 { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2486 { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2487 { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2488 { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2489 { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2490 { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity }, 2491 { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity }, 2492 { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity }, 2493 { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2494 { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2495 { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2496 { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2497 { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2498#if 0 2499// See Note 1. 2500 { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2501#endif 2502 { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2503 { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2504 { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2505 { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2506 { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2507 { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2508 { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2509 { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2510 { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2511 { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2512 { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2513 { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2514 // See Note 2. 2515 { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2516#if 0 2517// See Note 1. 2518 { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2519#endif 2520 { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2521 { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2522 { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2523 { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2524 { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2525 { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2526 { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2527 { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2528 { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN }, 2529 // See Note 2. 2530 { QNaN, MInf, "-nan", APFloat::opOK, APFloat::fcNaN }, 2531 { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN }, 2532 // See Note 2. 2533 { QNaN, MZero, "-nan", APFloat::opOK, APFloat::fcNaN }, 2534 { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2535#if 0 2536// See Note 1. 2537 { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2538#endif 2539 { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2540 // See Note 2. 2541 { QNaN, MNormalValue, "-nan", APFloat::opOK, APFloat::fcNaN }, 2542 { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2543 // See Note 2. 2544 { QNaN, MLargestValue, "-nan", APFloat::opOK, APFloat::fcNaN }, 2545 { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN }, 2546 // See Note 2. 2547 { QNaN, MSmallestValue, "-nan", APFloat::opOK, APFloat::fcNaN }, 2548 { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN }, 2549 // See Note 2. 2550 { QNaN, MSmallestNormalized, "-nan", APFloat::opOK, APFloat::fcNaN }, 2551#if 0 2552// See Note 1. 2553 { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2554 { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2555 { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2556 { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2557 { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2558 { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2559 { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2560 { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2561 { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2562 { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2563 { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2564 { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2565 { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2566 { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2567#endif 2568 { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2569 { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2570 { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2571 { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2572 { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2573#if 0 2574// See Note 1. 2575 { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2576#endif 2577 { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2578 { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2579 { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal }, 2580 { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal }, 2581 { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2582 { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2583 { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal }, 2584 { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal }, 2585 { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2586 { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2587 { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2588 { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2589 // See Note 2. 2590 { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2591#if 0 2592// See Note 1. 2593 { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2594#endif 2595 { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2596 { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2597 { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal }, 2598 { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal }, 2599 { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2600 { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2601 { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal }, 2602 { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal }, 2603 { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2604 { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2605 { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2606 { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2607 { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2608#if 0 2609// See Note 1. 2610 { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2611#endif 2612 { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2613 { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2614 { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2615 { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2616 { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2617 { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2618 { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity }, 2619 { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity }, 2620 { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2621 { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2622 { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2623 { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2624 // See Note 2. 2625 { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2626#if 0 2627// See Note 1. 2628 { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2629#endif 2630 { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2631 { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal }, 2632 { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2633 { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2634 { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity }, 2635 { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity }, 2636 { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity }, 2637 { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity }, 2638 { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2639 { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2640 { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2641 { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2642 { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2643#if 0 2644// See Note 1. 2645 { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2646#endif 2647 { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2648 { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2649 { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2650 { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2651 { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2652 { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2653 { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal }, 2654 { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal }, 2655 { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2656 { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2657 { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2658 { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2659 // See Note 2. 2660 { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2661#if 0 2662// See Note 1. 2663 { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2664#endif 2665 { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2666 { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal }, 2667 { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2668 { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2669 { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2670 { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2671 { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal }, 2672 { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal }, 2673 { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2674 { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2675 { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2676 { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2677 { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN }, 2678#if 0 2679// See Note 1. 2680 { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2681#endif 2682 { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2683 { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2684 { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2685 { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2686 { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal }, 2687 { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal }, 2688 { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2689 { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2690 { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero }, 2691 { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero }, 2692 { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2693 { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity }, 2694 // See Note 2. 2695 { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN }, 2696#if 0 2697// See Note 1. 2698 { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN }, 2699#endif 2700 { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2701 { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal }, 2702 { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero }, 2703 { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero }, 2704 { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal }, 2705 { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal }, 2706 { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2707 { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal }, 2708 }; 2709 2710 for (size_t i = 0; i < NumTests; ++i) { 2711 APFloat x(SpecialCaseTests[i].x); 2712 APFloat y(SpecialCaseTests[i].y); 2713 APFloat::opStatus status = x.divide(y, APFloat::rmNearestTiesToEven); 2714 2715 APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result); 2716 2717 EXPECT_TRUE(result.bitwiseIsEqual(x)); 2718 EXPECT_TRUE((int)status == SpecialCaseTests[i].status); 2719 EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category); 2720 } 2721} 2722 2723} 2724