1 // Tencent is pleased to support the open source community by making RapidJSON available. 2 // 3 // Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip. All rights reserved. 4 // 5 // Licensed under the MIT License (the "License"); you may not use this file except 6 // in compliance with the License. You may obtain a copy of the License at 7 // 8 // http://opensource.org/licenses/MIT 9 // 10 // Unless required by applicable law or agreed to in writing, software distributed 11 // under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR 12 // CONDITIONS OF ANY KIND, either express or implied. See the License for the 13 // specific language governing permissions and limitations under the License. 14 15 #include "unittest.h" 16 17 #include "rapidjson/internal/strtod.h" 18 19 #define BIGINTEGER_LITERAL(s) BigInteger(s, sizeof(s) - 1) 20 21 using namespace rapidjson::internal; 22 23 TEST(Strtod, CheckApproximationCase) { 24 static const int kSignificandSize = 52; 25 static const int kExponentBias = 0x3FF; 26 static const uint64_t kExponentMask = RAPIDJSON_UINT64_C2(0x7FF00000, 0x00000000); 27 static const uint64_t kSignificandMask = RAPIDJSON_UINT64_C2(0x000FFFFF, 0xFFFFFFFF); 28 static const uint64_t kHiddenBit = RAPIDJSON_UINT64_C2(0x00100000, 0x00000000); 29 30 // http://www.exploringbinary.com/using-integers-to-check-a-floating-point-approximation/ 31 // Let b = 0x1.465a72e467d88p-149 32 // = 5741268244528520 x 2^-201 33 union { 34 double d; 35 uint64_t u; 36 }u; 37 u.u = 0x465a72e467d88 | ((static_cast<uint64_t>(-149 + kExponentBias)) << kSignificandSize); 38 const double b = u.d; 39 const uint64_t bInt = (u.u & kSignificandMask) | kHiddenBit; 40 const int bExp = ((u.u & kExponentMask) >> kSignificandSize) - kExponentBias - kSignificandSize; 41 EXPECT_DOUBLE_EQ(1.7864e-45, b); 42 EXPECT_EQ(RAPIDJSON_UINT64_C2(0x001465a7, 0x2e467d88), bInt); 43 EXPECT_EQ(-201, bExp); 44 45 // Let d = 17864 x 10-49 46 const char dInt[] = "17864"; 47 const int dExp = -49; 48 49 // Let h = 2^(bExp-1) 50 const int hExp = bExp - 1; 51 EXPECT_EQ(-202, hExp); 52 53 int dS_Exp2 = 0; 54 int dS_Exp5 = 0; 55 int bS_Exp2 = 0; 56 int bS_Exp5 = 0; 57 int hS_Exp2 = 0; 58 int hS_Exp5 = 0; 59 60 // Adjust for decimal exponent 61 if (dExp >= 0) { 62 dS_Exp2 += dExp; 63 dS_Exp5 += dExp; 64 } 65 else { 66 bS_Exp2 -= dExp; 67 bS_Exp5 -= dExp; 68 hS_Exp2 -= dExp; 69 hS_Exp5 -= dExp; 70 } 71 72 // Adjust for binary exponent 73 if (bExp >= 0) 74 bS_Exp2 += bExp; 75 else { 76 dS_Exp2 -= bExp; 77 hS_Exp2 -= bExp; 78 } 79 80 // Adjust for half ulp exponent 81 if (hExp >= 0) 82 hS_Exp2 += hExp; 83 else { 84 dS_Exp2 -= hExp; 85 bS_Exp2 -= hExp; 86 } 87 88 // Remove common power of two factor from all three scaled values 89 int common_Exp2 = std::min(dS_Exp2, std::min(bS_Exp2, hS_Exp2)); 90 dS_Exp2 -= common_Exp2; 91 bS_Exp2 -= common_Exp2; 92 hS_Exp2 -= common_Exp2; 93 94 EXPECT_EQ(153, dS_Exp2); 95 EXPECT_EQ(0, dS_Exp5); 96 EXPECT_EQ(1, bS_Exp2); 97 EXPECT_EQ(49, bS_Exp5); 98 EXPECT_EQ(0, hS_Exp2); 99 EXPECT_EQ(49, hS_Exp5); 100 101 BigInteger dS = BIGINTEGER_LITERAL(dInt); 102 dS.MultiplyPow5(dS_Exp5) <<= dS_Exp2; 103 104 BigInteger bS(bInt); 105 bS.MultiplyPow5(bS_Exp5) <<= bS_Exp2; 106 107 BigInteger hS(1); 108 hS.MultiplyPow5(hS_Exp5) <<= hS_Exp2; 109 110 EXPECT_TRUE(BIGINTEGER_LITERAL("203970822259994138521801764465966248930731085529088") == dS); 111 EXPECT_TRUE(BIGINTEGER_LITERAL("203970822259994122305215569213032722473144531250000") == bS); 112 EXPECT_TRUE(BIGINTEGER_LITERAL("17763568394002504646778106689453125") == hS); 113 114 EXPECT_EQ(1, dS.Compare(bS)); 115 116 BigInteger delta(0); 117 EXPECT_FALSE(dS.Difference(bS, &delta)); 118 EXPECT_TRUE(BIGINTEGER_LITERAL("16216586195252933526457586554279088") == delta); 119 EXPECT_TRUE(bS.Difference(dS, &delta)); 120 EXPECT_TRUE(BIGINTEGER_LITERAL("16216586195252933526457586554279088") == delta); 121 122 EXPECT_EQ(-1, delta.Compare(hS)); 123 } 124
