internal Namespace Reference

Classes
class	BigInteger
struct	DiyFp
class	Double
struct	IsGenericValue
struct	IsGenericValueImpl
struct	IsGenericValueImpl< T, typename Void< typename T::EncodingType >::Type, typename Void< typename T::AllocatorType >::Type >
class	Stack
	A type-unsafe stack for storing different types of data. More...
singleton	StreamLocalCopy
class	StreamLocalCopy< Stream, 0 >
	Keep reference. More...
class	StreamLocalCopy< Stream, 1 >
	Do copy optimization. More...

Functions
DiyFp	GetCachedPowerByIndex (size_t index)
DiyFp	GetCachedPower (int e, int *K)
DiyFp	GetCachedPower10 (int exp, int *outExp)
void	GrisuRound (char *buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w)
unsigned	CountDecimalDigit32 (uint32_t n)
void	DigitGen (const DiyFp &W, const DiyFp &Mp, uint64_t delta, char *buffer, int *len, int *K)
void	Grisu2 (double value, char *buffer, int *length, int *K)
char *	WriteExponent (int K, char *buffer)
char *	Prettify (char *buffer, int length, int k)
char *	dtoa (double value, char *buffer)
const char *	GetDigitsLut ()
char *	u32toa (uint32_t value, char *buffer)
char *	i32toa (int32_t value, char *buffer)
char *	u64toa (uint64_t value, char *buffer)
char *	i64toa (int64_t value, char *buffer)
double	Pow10 (int n)
	Computes integer powers of 10 in double (10.0^n). More...
template<typename Ch >
SizeType	StrLen (const Ch *s)
	Custom strlen() which works on different character types. More...
double	FastPath (double significand, int exp)
double	StrtodNormalPrecision (double d, int p)
template<typename T >
T	Min3 (T a, T b, T c)
int	CheckWithinHalfULP (double b, const BigInteger &d, int dExp)
bool	StrtodFast (double d, int p, double *result)
bool	StrtodDiyFp (const char *decimals, size_t length, size_t decimalPosition, int exp, double *result)
double	StrtodBigInteger (double approx, const char *decimals, size_t length, size_t decimalPosition, int exp)
double	StrtodFullPrecision (double d, int p, const char *decimals, size_t length, size_t decimalPosition, int exp)

Function Documentation

int internal::CheckWithinHalfULP ( double  b, const BigInteger &  d, int  dExp  )

inline

 {
 const Double db(b);
 const uint64_t bInt = db.IntegerSignificand();
 const int bExp = db.IntegerExponent();
 const int hExp = bExp - 1;

 int dS_Exp2 = 0, dS_Exp5 = 0, bS_Exp2 = 0, bS_Exp5 = 0, hS_Exp2 = 0, hS_Exp5 = 0;

 // Adjust for decimal exponent
 if (dExp >= 0) {
 dS_Exp2 += dExp;
 dS_Exp5 += dExp;
 }
 else {
 bS_Exp2 -= dExp;
 bS_Exp5 -= dExp;
 hS_Exp2 -= dExp;
 hS_Exp5 -= dExp;
 }

 // Adjust for binary exponent
 if (bExp >= 0)
 bS_Exp2 += bExp;
 else {
 dS_Exp2 -= bExp;
 hS_Exp2 -= bExp;
 }

 // Adjust for half ulp exponent
 if (hExp >= 0)
 hS_Exp2 += hExp;
 else {
 dS_Exp2 -= hExp;
 bS_Exp2 -= hExp;
 }

 // Remove common power of two factor from all three scaled values
 int common_Exp2 = Min3(dS_Exp2, bS_Exp2, hS_Exp2);
 dS_Exp2 -= common_Exp2;
 bS_Exp2 -= common_Exp2;
 hS_Exp2 -= common_Exp2;

 BigInteger dS = d;
 dS.MultiplyPow5(dS_Exp5) <<= dS_Exp2;

 BigInteger bS(bInt);
 bS.MultiplyPow5(bS_Exp5) <<= bS_Exp2;

 BigInteger hS(1);
 hS.MultiplyPow5(hS_Exp5) <<= hS_Exp2;

 BigInteger delta(0);
 dS.Difference(bS, &delta);

 return delta.Compare(hS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned internal::CountDecimalDigit32 ( uint32_t  n )

inline

 {
 // Simple pure C++ implementation was faster than __builtin_clz version in this situation.
 if (n < 10) return 1;
 if (n < 100) return 2;
 if (n < 1000) return 3;
 if (n < 10000) return 4;
 if (n < 100000) return 5;
 if (n < 1000000) return 6;
 if (n < 10000000) return 7;
 if (n < 100000000) return 8;
 // Will not reach 10 digits in DigitGen()
 //if (n < 1000000000) return 9;
 //return 10;
 return 9;
}

Here is the caller graph for this function:

void internal::DigitGen ( const DiyFp &  W, const DiyFp &  Mp, uint64_t  delta, char *  buffer, int *  len, int *  K  )

inline

 {
 static const uint32_t kPow10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 };
 const DiyFp one(uint64_t(1) << -Mp.e, Mp.e);
 const DiyFp wp_w = Mp - W;
 uint32_t p1 = static_cast<uint32_t>(Mp.f >> -one.e);
 uint64_t p2 = Mp.f & (one.f - 1);
 int kappa = CountDecimalDigit32(p1); // kappa in [0, 9]
 *len = 0;

 while (kappa > 0) {
 uint32_t d = 0;
 switch (kappa) {
 case 9: d = p1 / 100000000; p1 %= 100000000; break;
 case 8: d = p1 / 10000000; p1 %= 10000000; break;
 case 7: d = p1 / 1000000; p1 %= 1000000; break;
 case 6: d = p1 / 100000; p1 %= 100000; break;
 case 5: d = p1 / 10000; p1 %= 10000; break;
 case 4: d = p1 / 1000; p1 %= 1000; break;
 case 3: d = p1 / 100; p1 %= 100; break;
 case 2: d = p1 / 10; p1 %= 10; break;
 case 1: d = p1; p1 = 0; break;
 default:;
 }
 if (d || *len)
 buffer[(*len)++] = static_cast<char>('0' + static_cast<char>(d));
 kappa--;
 uint64_t tmp = (static_cast<uint64_t>(p1) << -one.e) + p2;
 if (tmp <= delta) {
 *K += kappa;
 GrisuRound(buffer, *len, delta, tmp, static_cast<uint64_t>(kPow10[kappa]) << -one.e, wp_w.f);
 return;
 }
 }

 // kappa = 0
 for (;;) {
 p2 *= 10;
 delta *= 10;
 char d = static_cast<char>(p2 >> -one.e);
 if (d || *len)
 buffer[(*len)++] = static_cast<char>('0' + d);
 p2 &= one.f - 1;
 kappa--;
 if (p2 < delta) {
 *K += kappa;
 GrisuRound(buffer, *len, delta, p2, one.f, wp_w.f * kPow10[-kappa]);
 return;
 }
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* internal::dtoa ( double  value, char *  buffer  )

inline

 {
 Double d(value);
 if (d.IsZero()) {
 if (d.Sign())
 *buffer++ = '-'; // -0.0, Issue #289
 buffer[0] = '0';
 buffer[1] = '.';
 buffer[2] = '0';
 return &buffer[3];
 }
 else {
 if (value < 0) {
 *buffer++ = '-';
 value = -value;
 }
 int length, K;
 Grisu2(value, buffer, &length, &K);
 return Prettify(buffer, length, K);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

double internal::FastPath ( double  significand, int  exp  )

inline

 {
 if (exp < -308)
 return 0.0;
 else if (exp >= 0)
 return significand * internal::Pow10(exp);
 else
 return significand / internal::Pow10(-exp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

DiyFp internal::GetCachedPower ( int  e, int *  K  )

inline

 {

 //int k = static_cast<int>(ceil((-61 - e) * 0.30102999566398114)) + 374;
 double dk = (-61 - e) * 0.30102999566398114 + 347; // dk must be positive, so can do ceiling in positive
 int k = static_cast<int>(dk);
 if (dk - k > 0.0)
 k++;

 unsigned index = static_cast<unsigned>((k >> 3) + 1);
 *K = -(-348 + static_cast<int>(index << 3)); // decimal exponent no need lookup table

 return GetCachedPowerByIndex(index);
}

Here is the call graph for this function:

Here is the caller graph for this function:

DiyFp internal::GetCachedPower10 ( int  exp, int *  outExp  )

inline

 {
 unsigned index = (exp + 348) / 8;
 *outExp = -348 + index * 8;
 return GetCachedPowerByIndex(index);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

DiyFp internal::GetCachedPowerByIndex ( size_t  index )

inline

 {
 // 10^-348, 10^-340, ..., 10^340
 static const uint64_t kCachedPowers_F[] = {
 RAPIDJSON_UINT64_C2(0xfa8fd5a0, 0x081c0288), RAPIDJSON_UINT64_C2(0xbaaee17f, 0xa23ebf76),
 RAPIDJSON_UINT64_C2(0x8b16fb20, 0x3055ac76), RAPIDJSON_UINT64_C2(0xcf42894a, 0x5dce35ea),
 RAPIDJSON_UINT64_C2(0x9a6bb0aa, 0x55653b2d), RAPIDJSON_UINT64_C2(0xe61acf03, 0x3d1a45df),
 RAPIDJSON_UINT64_C2(0xab70fe17, 0xc79ac6ca), RAPIDJSON_UINT64_C2(0xff77b1fc, 0xbebcdc4f),
 RAPIDJSON_UINT64_C2(0xbe5691ef, 0x416bd60c), RAPIDJSON_UINT64_C2(0x8dd01fad, 0x907ffc3c),
 RAPIDJSON_UINT64_C2(0xd3515c28, 0x31559a83), RAPIDJSON_UINT64_C2(0x9d71ac8f, 0xada6c9b5),
 RAPIDJSON_UINT64_C2(0xea9c2277, 0x23ee8bcb), RAPIDJSON_UINT64_C2(0xaecc4991, 0x4078536d),
 RAPIDJSON_UINT64_C2(0x823c1279, 0x5db6ce57), RAPIDJSON_UINT64_C2(0xc2109436, 0x4dfb5637),
 RAPIDJSON_UINT64_C2(0x9096ea6f, 0x3848984f), RAPIDJSON_UINT64_C2(0xd77485cb, 0x25823ac7),
 RAPIDJSON_UINT64_C2(0xa086cfcd, 0x97bf97f4), RAPIDJSON_UINT64_C2(0xef340a98, 0x172aace5),
 RAPIDJSON_UINT64_C2(0xb23867fb, 0x2a35b28e), RAPIDJSON_UINT64_C2(0x84c8d4df, 0xd2c63f3b),
 RAPIDJSON_UINT64_C2(0xc5dd4427, 0x1ad3cdba), RAPIDJSON_UINT64_C2(0x936b9fce, 0xbb25c996),
 RAPIDJSON_UINT64_C2(0xdbac6c24, 0x7d62a584), RAPIDJSON_UINT64_C2(0xa3ab6658, 0x0d5fdaf6),
 RAPIDJSON_UINT64_C2(0xf3e2f893, 0xdec3f126), RAPIDJSON_UINT64_C2(0xb5b5ada8, 0xaaff80b8),
 RAPIDJSON_UINT64_C2(0x87625f05, 0x6c7c4a8b), RAPIDJSON_UINT64_C2(0xc9bcff60, 0x34c13053),
 RAPIDJSON_UINT64_C2(0x964e858c, 0x91ba2655), RAPIDJSON_UINT64_C2(0xdff97724, 0x70297ebd),
 RAPIDJSON_UINT64_C2(0xa6dfbd9f, 0xb8e5b88f), RAPIDJSON_UINT64_C2(0xf8a95fcf, 0x88747d94),
 RAPIDJSON_UINT64_C2(0xb9447093, 0x8fa89bcf), RAPIDJSON_UINT64_C2(0x8a08f0f8, 0xbf0f156b),
 RAPIDJSON_UINT64_C2(0xcdb02555, 0x653131b6), RAPIDJSON_UINT64_C2(0x993fe2c6, 0xd07b7fac),
 RAPIDJSON_UINT64_C2(0xe45c10c4, 0x2a2b3b06), RAPIDJSON_UINT64_C2(0xaa242499, 0x697392d3),
 RAPIDJSON_UINT64_C2(0xfd87b5f2, 0x8300ca0e), RAPIDJSON_UINT64_C2(0xbce50864, 0x92111aeb),
 RAPIDJSON_UINT64_C2(0x8cbccc09, 0x6f5088cc), RAPIDJSON_UINT64_C2(0xd1b71758, 0xe219652c),
 RAPIDJSON_UINT64_C2(0x9c400000, 0x00000000), RAPIDJSON_UINT64_C2(0xe8d4a510, 0x00000000),
 RAPIDJSON_UINT64_C2(0xad78ebc5, 0xac620000), RAPIDJSON_UINT64_C2(0x813f3978, 0xf8940984),
 RAPIDJSON_UINT64_C2(0xc097ce7b, 0xc90715b3), RAPIDJSON_UINT64_C2(0x8f7e32ce, 0x7bea5c70),
 RAPIDJSON_UINT64_C2(0xd5d238a4, 0xabe98068), RAPIDJSON_UINT64_C2(0x9f4f2726, 0x179a2245),
 RAPIDJSON_UINT64_C2(0xed63a231, 0xd4c4fb27), RAPIDJSON_UINT64_C2(0xb0de6538, 0x8cc8ada8),
 RAPIDJSON_UINT64_C2(0x83c7088e, 0x1aab65db), RAPIDJSON_UINT64_C2(0xc45d1df9, 0x42711d9a),
 RAPIDJSON_UINT64_C2(0x924d692c, 0xa61be758), RAPIDJSON_UINT64_C2(0xda01ee64, 0x1a708dea),
 RAPIDJSON_UINT64_C2(0xa26da399, 0x9aef774a), RAPIDJSON_UINT64_C2(0xf209787b, 0xb47d6b85),
 RAPIDJSON_UINT64_C2(0xb454e4a1, 0x79dd1877), RAPIDJSON_UINT64_C2(0x865b8692, 0x5b9bc5c2),
 RAPIDJSON_UINT64_C2(0xc83553c5, 0xc8965d3d), RAPIDJSON_UINT64_C2(0x952ab45c, 0xfa97a0b3),
 RAPIDJSON_UINT64_C2(0xde469fbd, 0x99a05fe3), RAPIDJSON_UINT64_C2(0xa59bc234, 0xdb398c25),
 RAPIDJSON_UINT64_C2(0xf6c69a72, 0xa3989f5c), RAPIDJSON_UINT64_C2(0xb7dcbf53, 0x54e9bece),
 RAPIDJSON_UINT64_C2(0x88fcf317, 0xf22241e2), RAPIDJSON_UINT64_C2(0xcc20ce9b, 0xd35c78a5),
 RAPIDJSON_UINT64_C2(0x98165af3, 0x7b2153df), RAPIDJSON_UINT64_C2(0xe2a0b5dc, 0x971f303a),
 RAPIDJSON_UINT64_C2(0xa8d9d153, 0x5ce3b396), RAPIDJSON_UINT64_C2(0xfb9b7cd9, 0xa4a7443c),
 RAPIDJSON_UINT64_C2(0xbb764c4c, 0xa7a44410), RAPIDJSON_UINT64_C2(0x8bab8eef, 0xb6409c1a),
 RAPIDJSON_UINT64_C2(0xd01fef10, 0xa657842c), RAPIDJSON_UINT64_C2(0x9b10a4e5, 0xe9913129),
 RAPIDJSON_UINT64_C2(0xe7109bfb, 0xa19c0c9d), RAPIDJSON_UINT64_C2(0xac2820d9, 0x623bf429),
 RAPIDJSON_UINT64_C2(0x80444b5e, 0x7aa7cf85), RAPIDJSON_UINT64_C2(0xbf21e440, 0x03acdd2d),
 RAPIDJSON_UINT64_C2(0x8e679c2f, 0x5e44ff8f), RAPIDJSON_UINT64_C2(0xd433179d, 0x9c8cb841),
 RAPIDJSON_UINT64_C2(0x9e19db92, 0xb4e31ba9), RAPIDJSON_UINT64_C2(0xeb96bf6e, 0xbadf77d9),
 RAPIDJSON_UINT64_C2(0xaf87023b, 0x9bf0ee6b)
 };
 static const int16_t kCachedPowers_E[] = {
 -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,
 -954, -927, -901, -874, -847, -821, -794, -768, -741, -715,
 -688, -661, -635, -608, -582, -555, -529, -502, -475, -449,
 -422, -396, -369, -343, -316, -289, -263, -236, -210, -183,
 -157, -130, -103, -77, -50, -24, 3, 30, 56, 83,
 109, 136, 162, 189, 216, 242, 269, 295, 322, 348,
 375, 402, 428, 455, 481, 508, 534, 561, 588, 614,
 641, 667, 694, 720, 747, 774, 800, 827, 853, 880,
 907, 933, 960, 986, 1013, 1039, 1066
 };
 return DiyFp(kCachedPowers_F[index], kCachedPowers_E[index]);
}

Here is the caller graph for this function:

const char* internal::GetDigitsLut ( )

inline

 {
 static const char cDigitsLut[200] = {
 '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9',
 '1','0','1','1','1','2','1','3','1','4','1','5','1','6','1','7','1','8','1','9',
 '2','0','2','1','2','2','2','3','2','4','2','5','2','6','2','7','2','8','2','9',
 '3','0','3','1','3','2','3','3','3','4','3','5','3','6','3','7','3','8','3','9',
 '4','0','4','1','4','2','4','3','4','4','4','5','4','6','4','7','4','8','4','9',
 '5','0','5','1','5','2','5','3','5','4','5','5','5','6','5','7','5','8','5','9',
 '6','0','6','1','6','2','6','3','6','4','6','5','6','6','6','7','6','8','6','9',
 '7','0','7','1','7','2','7','3','7','4','7','5','7','6','7','7','7','8','7','9',
 '8','0','8','1','8','2','8','3','8','4','8','5','8','6','8','7','8','8','8','9',
 '9','0','9','1','9','2','9','3','9','4','9','5','9','6','9','7','9','8','9','9'
 };
 return cDigitsLut;
}

Here is the caller graph for this function:

void internal::Grisu2 ( double  value, char *  buffer, int *  length, int *  K  )

inline

 {
 const DiyFp v(value);
 DiyFp w_m, w_p;
 v.NormalizedBoundaries(&w_m, &w_p);

 const DiyFp c_mk = GetCachedPower(w_p.e, K);
 const DiyFp W = v.Normalize() * c_mk;
 DiyFp Wp = w_p * c_mk;
 DiyFp Wm = w_m * c_mk;
 Wm.f++;
 Wp.f--;
 DigitGen(W, Wp, Wp.f - Wm.f, buffer, length, K);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void internal::GrisuRound ( char *  buffer, int  len, uint64_t  delta, uint64_t  rest, uint64_t  ten_kappa, uint64_t  wp_w  )

inline

closer

 {
 while (rest < wp_w && delta - rest >= ten_kappa &&
 (rest + ten_kappa < wp_w || 
 wp_w - rest > rest + ten_kappa - wp_w)) {
 buffer[len - 1]--;
 rest += ten_kappa;
 }
}

Here is the caller graph for this function:

char* internal::i32toa ( int32_t  value, char *  buffer  )

inline

 {
 uint32_t u = static_cast<uint32_t>(value);
 if (value < 0) {
 *buffer++ = '-';
 u = ~u + 1;
 }

 return u32toa(u, buffer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* internal::i64toa ( int64_t  value, char *  buffer  )

inline

 {
 uint64_t u = static_cast<uint64_t>(value);
 if (value < 0) {
 *buffer++ = '-';
 u = ~u + 1;
 }

 return u64toa(u, buffer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

T internal::Min3 ( T  a, T  b, T  c  )

inline

 {
 T m = a;
 if (m > b) m = b;
 if (m > c) m = c;
 return m;
}

Here is the caller graph for this function:

double internal::Pow10 ( int  n )

inline

Computes integer powers of 10 in double (10.0^n).

This function uses lookup table for fast and accurate results.

Parameters

n	non-negative exponent. Must <= 308.

Returns

10.0^n

 {
 static const double e[] = { // 1e-0...1e308: 309 * 8 bytes = 2472 bytes
 1e+0, 
 1e+1, 1e+2, 1e+3, 1e+4, 1e+5, 1e+6, 1e+7, 1e+8, 1e+9, 1e+10, 1e+11, 1e+12, 1e+13, 1e+14, 1e+15, 1e+16, 1e+17, 1e+18, 1e+19, 1e+20, 
 1e+21, 1e+22, 1e+23, 1e+24, 1e+25, 1e+26, 1e+27, 1e+28, 1e+29, 1e+30, 1e+31, 1e+32, 1e+33, 1e+34, 1e+35, 1e+36, 1e+37, 1e+38, 1e+39, 1e+40,
 1e+41, 1e+42, 1e+43, 1e+44, 1e+45, 1e+46, 1e+47, 1e+48, 1e+49, 1e+50, 1e+51, 1e+52, 1e+53, 1e+54, 1e+55, 1e+56, 1e+57, 1e+58, 1e+59, 1e+60,
 1e+61, 1e+62, 1e+63, 1e+64, 1e+65, 1e+66, 1e+67, 1e+68, 1e+69, 1e+70, 1e+71, 1e+72, 1e+73, 1e+74, 1e+75, 1e+76, 1e+77, 1e+78, 1e+79, 1e+80,
 1e+81, 1e+82, 1e+83, 1e+84, 1e+85, 1e+86, 1e+87, 1e+88, 1e+89, 1e+90, 1e+91, 1e+92, 1e+93, 1e+94, 1e+95, 1e+96, 1e+97, 1e+98, 1e+99, 1e+100,
 1e+101,1e+102,1e+103,1e+104,1e+105,1e+106,1e+107,1e+108,1e+109,1e+110,1e+111,1e+112,1e+113,1e+114,1e+115,1e+116,1e+117,1e+118,1e+119,1e+120,
 1e+121,1e+122,1e+123,1e+124,1e+125,1e+126,1e+127,1e+128,1e+129,1e+130,1e+131,1e+132,1e+133,1e+134,1e+135,1e+136,1e+137,1e+138,1e+139,1e+140,
 1e+141,1e+142,1e+143,1e+144,1e+145,1e+146,1e+147,1e+148,1e+149,1e+150,1e+151,1e+152,1e+153,1e+154,1e+155,1e+156,1e+157,1e+158,1e+159,1e+160,
 1e+161,1e+162,1e+163,1e+164,1e+165,1e+166,1e+167,1e+168,1e+169,1e+170,1e+171,1e+172,1e+173,1e+174,1e+175,1e+176,1e+177,1e+178,1e+179,1e+180,
 1e+181,1e+182,1e+183,1e+184,1e+185,1e+186,1e+187,1e+188,1e+189,1e+190,1e+191,1e+192,1e+193,1e+194,1e+195,1e+196,1e+197,1e+198,1e+199,1e+200,
 1e+201,1e+202,1e+203,1e+204,1e+205,1e+206,1e+207,1e+208,1e+209,1e+210,1e+211,1e+212,1e+213,1e+214,1e+215,1e+216,1e+217,1e+218,1e+219,1e+220,
 1e+221,1e+222,1e+223,1e+224,1e+225,1e+226,1e+227,1e+228,1e+229,1e+230,1e+231,1e+232,1e+233,1e+234,1e+235,1e+236,1e+237,1e+238,1e+239,1e+240,
 1e+241,1e+242,1e+243,1e+244,1e+245,1e+246,1e+247,1e+248,1e+249,1e+250,1e+251,1e+252,1e+253,1e+254,1e+255,1e+256,1e+257,1e+258,1e+259,1e+260,
 1e+261,1e+262,1e+263,1e+264,1e+265,1e+266,1e+267,1e+268,1e+269,1e+270,1e+271,1e+272,1e+273,1e+274,1e+275,1e+276,1e+277,1e+278,1e+279,1e+280,
 1e+281,1e+282,1e+283,1e+284,1e+285,1e+286,1e+287,1e+288,1e+289,1e+290,1e+291,1e+292,1e+293,1e+294,1e+295,1e+296,1e+297,1e+298,1e+299,1e+300,
 1e+301,1e+302,1e+303,1e+304,1e+305,1e+306,1e+307,1e+308
 };
 RAPIDJSON_ASSERT(n >= 0 && n <= 308);
 return e[n];
}

Here is the caller graph for this function:

char* internal::Prettify ( char *  buffer, int  length, int  k  )

inline

 {
 const int kk = length + k; // 10^(kk-1) <= v < 10^kk

 if (length <= kk && kk <= 21) {
 // 1234e7 -> 12340000000
 for (int i = length; i < kk; i++)
 buffer[i] = '0';
 buffer[kk] = '.';
 buffer[kk + 1] = '0';
 return &buffer[kk + 2];
 }
 else if (0 < kk && kk <= 21) {
 // 1234e-2 -> 12.34
 std::memmove(&buffer[kk + 1], &buffer[kk], length - kk);
 buffer[kk] = '.';
 return &buffer[length + 1];
 }
 else if (-6 < kk && kk <= 0) {
 // 1234e-6 -> 0.001234
 const int offset = 2 - kk;
 std::memmove(&buffer[offset], &buffer[0], length);
 buffer[0] = '0';
 buffer[1] = '.';
 for (int i = 2; i < offset; i++)
 buffer[i] = '0';
 return &buffer[length + offset];
 }
 else if (length == 1) {
 // 1e30
 buffer[1] = 'e';
 return WriteExponent(kk - 1, &buffer[2]);
 }
 else {
 // 1234e30 -> 1.234e33
 std::memmove(&buffer[2], &buffer[1], length - 1);
 buffer[1] = '.';
 buffer[length + 1] = 'e';
 return WriteExponent(kk - 1, &buffer[0 + length + 2]);
 }
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename Ch >

SizeType internal::StrLen ( const Ch *  s )

inline

Custom strlen() which works on different character types.

Template Parameters

Ch	Character type (e.g. char, wchar_t, short)

Parameters

s	Null-terminated input string.

Returns

Number of characters in the string.

Note

This has the same semantics as strlen(), the return value is not number of Unicode codepoints.

 {
 const Ch* p = s;
 while (*p) ++p;
 return SizeType(p - s);
}

Here is the caller graph for this function:

double internal::StrtodBigInteger ( double  approx, const char *  decimals, size_t  length, size_t  decimalPosition, int  exp  )

inline

 {
 const BigInteger dInt(decimals, length);
 const int dExp = (int)decimalPosition - (int)length + exp;
 Double a(approx);
 int cmp = CheckWithinHalfULP(a.Value(), dInt, dExp);
 if (cmp < 0)
 return a.Value(); // within half ULP
 else if (cmp == 0) {
 // Round towards even
 if (a.Significand() & 1)
 return a.NextPositiveDouble();
 else
 return a.Value();
 }
 else // adjustment
 return a.NextPositiveDouble();
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool internal::StrtodDiyFp ( const char *  decimals, size_t  length, size_t  decimalPosition, int  exp, double *  result  )

inline

 {
 uint64_t significand = 0;
 size_t i = 0; // 2^64 - 1 = 18446744073709551615, 1844674407370955161 = 0x1999999999999999 
 for (; i < length; i++) {
 if (significand > RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) ||
 (significand == RAPIDJSON_UINT64_C2(0x19999999, 0x99999999) && decimals[i] > '5'))
 break;
 significand = significand * 10 + (decimals[i] - '0');
 }
 
 if (i < length && decimals[i] >= '5') // Rounding
 significand++;

 size_t remaining = length - i;
 const unsigned kUlpShift = 3;
 const unsigned kUlp = 1 << kUlpShift;
 int error = (remaining == 0) ? 0 : kUlp / 2;

 DiyFp v(significand, 0);
 v = v.Normalize();
 error <<= -v.e;

 const int dExp = (int)decimalPosition - (int)i + exp;

 int actualExp;
 DiyFp cachedPower = GetCachedPower10(dExp, &actualExp);
 if (actualExp != dExp) {
 static const DiyFp kPow10[] = {
 DiyFp(RAPIDJSON_UINT64_C2(0xa0000000, 00000000), -60), // 10^1
 DiyFp(RAPIDJSON_UINT64_C2(0xc8000000, 00000000), -57), // 10^2
 DiyFp(RAPIDJSON_UINT64_C2(0xfa000000, 00000000), -54), // 10^3
 DiyFp(RAPIDJSON_UINT64_C2(0x9c400000, 00000000), -50), // 10^4
 DiyFp(RAPIDJSON_UINT64_C2(0xc3500000, 00000000), -47), // 10^5
 DiyFp(RAPIDJSON_UINT64_C2(0xf4240000, 00000000), -44), // 10^6
 DiyFp(RAPIDJSON_UINT64_C2(0x98968000, 00000000), -40) // 10^7
 };
 int adjustment = dExp - actualExp - 1;
 RAPIDJSON_ASSERT(adjustment >= 0 && adjustment < 7);
 v = v * kPow10[adjustment];
 if (length + adjustment > 19) // has more digits than decimal digits in 64-bit
 error += kUlp / 2;
 }

 v = v * cachedPower;

 error += kUlp + (error == 0 ? 0 : 1);

 const int oldExp = v.e;
 v = v.Normalize();
 error <<= oldExp - v.e;

 const unsigned effectiveSignificandSize = Double::EffectiveSignificandSize(64 + v.e);
 unsigned precisionSize = 64 - effectiveSignificandSize;
 if (precisionSize + kUlpShift >= 64) {
 unsigned scaleExp = (precisionSize + kUlpShift) - 63;
 v.f >>= scaleExp;
 v.e += scaleExp; 
 error = (error >> scaleExp) + 1 + kUlp;
 precisionSize -= scaleExp;
 }

 DiyFp rounded(v.f >> precisionSize, v.e + precisionSize);
 const uint64_t precisionBits = (v.f & ((uint64_t(1) << precisionSize) - 1)) * kUlp;
 const uint64_t halfWay = (uint64_t(1) << (precisionSize - 1)) * kUlp;
 if (precisionBits >= halfWay + error) {
 rounded.f++;
 if (rounded.f & (DiyFp::kDpHiddenBit << 1)) { // rounding overflows mantissa (issue #340)
 rounded.f >>= 1;
 rounded.e++;
 }
 }

 *result = rounded.ToDouble();

 return halfWay - error >= precisionBits || precisionBits >= halfWay + error;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool internal::StrtodFast ( double  d, int  p, double *  result  )

inline

 {
 // Use fast path for string-to-double conversion if possible
 // see http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/
 if (p > 22 && p < 22 + 16) {
 // Fast Path Cases In Disguise
 d *= internal::Pow10(p - 22);
 p = 22;
 }

 if (p >= -22 && p <= 22 && d <= 9007199254740991.0) { // 2^53 - 1
 *result = FastPath(d, p);
 return true;
 }
 else
 return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

double internal::StrtodFullPrecision ( double  d, int  p, const char *  decimals, size_t  length, size_t  decimalPosition, int  exp  )

inline

 {
 RAPIDJSON_ASSERT(d >= 0.0);
 RAPIDJSON_ASSERT(length >= 1);

 double result;
 if (StrtodFast(d, p, &result))
 return result;

 // Trim leading zeros
 while (*decimals == '0' && length > 1) {
 length--;
 decimals++;
 decimalPosition--;
 }

 // Trim trailing zeros
 while (decimals[length - 1] == '0' && length > 1) {
 length--;
 decimalPosition--;
 exp++;
 }

 // Trim right-most digits
 const int kMaxDecimalDigit = 780;
 if ((int)length > kMaxDecimalDigit) {
 int delta = (int(length) - kMaxDecimalDigit);
 exp += delta;
 decimalPosition -= delta;
 length = kMaxDecimalDigit;
 }

 // If too small, underflow to zero
 if (int(length) + exp < -324)
 return 0.0;

 if (StrtodDiyFp(decimals, length, decimalPosition, exp, &result))
 return result;

 // Use approximation from StrtodDiyFp and make adjustment with BigInteger comparison
 return StrtodBigInteger(result, decimals, length, decimalPosition, exp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

double internal::StrtodNormalPrecision ( double  d, int  p  )

inline

 {
 if (p < -308) {
 // Prevent expSum < -308, making Pow10(p) = 0
 d = FastPath(d, -308);
 d = FastPath(d, p + 308);
 }
 else
 d = FastPath(d, p);
 return d;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* internal::u32toa ( uint32_t  value, char *  buffer  )

inline

 {
 const char* cDigitsLut = GetDigitsLut();

 if (value < 10000) {
 const uint32_t d1 = (value / 100) << 1;
 const uint32_t d2 = (value % 100) << 1;
 
 if (value >= 1000)
 *buffer++ = cDigitsLut[d1];
 if (value >= 100)
 *buffer++ = cDigitsLut[d1 + 1];
 if (value >= 10)
 *buffer++ = cDigitsLut[d2];
 *buffer++ = cDigitsLut[d2 + 1];
 }
 else if (value < 100000000) {
 // value = bbbbcccc
 const uint32_t b = value / 10000;
 const uint32_t c = value % 10000;
 
 const uint32_t d1 = (b / 100) << 1;
 const uint32_t d2 = (b % 100) << 1;
 
 const uint32_t d3 = (c / 100) << 1;
 const uint32_t d4 = (c % 100) << 1;
 
 if (value >= 10000000)
 *buffer++ = cDigitsLut[d1];
 if (value >= 1000000)
 *buffer++ = cDigitsLut[d1 + 1];
 if (value >= 100000)
 *buffer++ = cDigitsLut[d2];
 *buffer++ = cDigitsLut[d2 + 1];
 
 *buffer++ = cDigitsLut[d3];
 *buffer++ = cDigitsLut[d3 + 1];
 *buffer++ = cDigitsLut[d4];
 *buffer++ = cDigitsLut[d4 + 1];
 }
 else {
 // value = aabbbbcccc in decimal
 
 const uint32_t a = value / 100000000; // 1 to 42
 value %= 100000000;
 
 if (a >= 10) {
 const unsigned i = a << 1;
 *buffer++ = cDigitsLut[i];
 *buffer++ = cDigitsLut[i + 1];
 }
 else
 *buffer++ = static_cast<char>('0' + static_cast<char>(a));

 const uint32_t b = value / 10000; // 0 to 9999
 const uint32_t c = value % 10000; // 0 to 9999
 
 const uint32_t d1 = (b / 100) << 1;
 const uint32_t d2 = (b % 100) << 1;
 
 const uint32_t d3 = (c / 100) << 1;
 const uint32_t d4 = (c % 100) << 1;
 
 *buffer++ = cDigitsLut[d1];
 *buffer++ = cDigitsLut[d1 + 1];
 *buffer++ = cDigitsLut[d2];
 *buffer++ = cDigitsLut[d2 + 1];
 *buffer++ = cDigitsLut[d3];
 *buffer++ = cDigitsLut[d3 + 1];
 *buffer++ = cDigitsLut[d4];
 *buffer++ = cDigitsLut[d4 + 1];
 }
 return buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* internal::u64toa ( uint64_t  value, char *  buffer  )

inline

 {
 const char* cDigitsLut = GetDigitsLut();
 const uint64_t kTen8 = 100000000;
 const uint64_t kTen9 = kTen8 * 10;
 const uint64_t kTen10 = kTen8 * 100;
 const uint64_t kTen11 = kTen8 * 1000;
 const uint64_t kTen12 = kTen8 * 10000;
 const uint64_t kTen13 = kTen8 * 100000;
 const uint64_t kTen14 = kTen8 * 1000000;
 const uint64_t kTen15 = kTen8 * 10000000;
 const uint64_t kTen16 = kTen8 * kTen8;
 
 if (value < kTen8) {
 uint32_t v = static_cast<uint32_t>(value);
 if (v < 10000) {
 const uint32_t d1 = (v / 100) << 1;
 const uint32_t d2 = (v % 100) << 1;
 
 if (v >= 1000)
 *buffer++ = cDigitsLut[d1];
 if (v >= 100)
 *buffer++ = cDigitsLut[d1 + 1];
 if (v >= 10)
 *buffer++ = cDigitsLut[d2];
 *buffer++ = cDigitsLut[d2 + 1];
 }
 else {
 // value = bbbbcccc
 const uint32_t b = v / 10000;
 const uint32_t c = v % 10000;
 
 const uint32_t d1 = (b / 100) << 1;
 const uint32_t d2 = (b % 100) << 1;
 
 const uint32_t d3 = (c / 100) << 1;
 const uint32_t d4 = (c % 100) << 1;
 
 if (value >= 10000000)
 *buffer++ = cDigitsLut[d1];
 if (value >= 1000000)
 *buffer++ = cDigitsLut[d1 + 1];
 if (value >= 100000)
 *buffer++ = cDigitsLut[d2];
 *buffer++ = cDigitsLut[d2 + 1];
 
 *buffer++ = cDigitsLut[d3];
 *buffer++ = cDigitsLut[d3 + 1];
 *buffer++ = cDigitsLut[d4];
 *buffer++ = cDigitsLut[d4 + 1];
 }
 }
 else if (value < kTen16) {
 const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
 const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
 
 const uint32_t b0 = v0 / 10000;
 const uint32_t c0 = v0 % 10000;
 
 const uint32_t d1 = (b0 / 100) << 1;
 const uint32_t d2 = (b0 % 100) << 1;
 
 const uint32_t d3 = (c0 / 100) << 1;
 const uint32_t d4 = (c0 % 100) << 1;

 const uint32_t b1 = v1 / 10000;
 const uint32_t c1 = v1 % 10000;
 
 const uint32_t d5 = (b1 / 100) << 1;
 const uint32_t d6 = (b1 % 100) << 1;
 
 const uint32_t d7 = (c1 / 100) << 1;
 const uint32_t d8 = (c1 % 100) << 1;

 if (value >= kTen15)
 *buffer++ = cDigitsLut[d1];
 if (value >= kTen14)
 *buffer++ = cDigitsLut[d1 + 1];
 if (value >= kTen13)
 *buffer++ = cDigitsLut[d2];
 if (value >= kTen12)
 *buffer++ = cDigitsLut[d2 + 1];
 if (value >= kTen11)
 *buffer++ = cDigitsLut[d3];
 if (value >= kTen10)
 *buffer++ = cDigitsLut[d3 + 1];
 if (value >= kTen9)
 *buffer++ = cDigitsLut[d4];
 if (value >= kTen8)
 *buffer++ = cDigitsLut[d4 + 1];
 
 *buffer++ = cDigitsLut[d5];
 *buffer++ = cDigitsLut[d5 + 1];
 *buffer++ = cDigitsLut[d6];
 *buffer++ = cDigitsLut[d6 + 1];
 *buffer++ = cDigitsLut[d7];
 *buffer++ = cDigitsLut[d7 + 1];
 *buffer++ = cDigitsLut[d8];
 *buffer++ = cDigitsLut[d8 + 1];
 }
 else {
 const uint32_t a = static_cast<uint32_t>(value / kTen16); // 1 to 1844
 value %= kTen16;
 
 if (a < 10)
 *buffer++ = static_cast<char>('0' + static_cast<char>(a));
 else if (a < 100) {
 const uint32_t i = a << 1;
 *buffer++ = cDigitsLut[i];
 *buffer++ = cDigitsLut[i + 1];
 }
 else if (a < 1000) {
 *buffer++ = static_cast<char>('0' + static_cast<char>(a / 100));
 
 const uint32_t i = (a % 100) << 1;
 *buffer++ = cDigitsLut[i];
 *buffer++ = cDigitsLut[i + 1];
 }
 else {
 const uint32_t i = (a / 100) << 1;
 const uint32_t j = (a % 100) << 1;
 *buffer++ = cDigitsLut[i];
 *buffer++ = cDigitsLut[i + 1];
 *buffer++ = cDigitsLut[j];
 *buffer++ = cDigitsLut[j + 1];
 }
 
 const uint32_t v0 = static_cast<uint32_t>(value / kTen8);
 const uint32_t v1 = static_cast<uint32_t>(value % kTen8);
 
 const uint32_t b0 = v0 / 10000;
 const uint32_t c0 = v0 % 10000;
 
 const uint32_t d1 = (b0 / 100) << 1;
 const uint32_t d2 = (b0 % 100) << 1;
 
 const uint32_t d3 = (c0 / 100) << 1;
 const uint32_t d4 = (c0 % 100) << 1;
 
 const uint32_t b1 = v1 / 10000;
 const uint32_t c1 = v1 % 10000;
 
 const uint32_t d5 = (b1 / 100) << 1;
 const uint32_t d6 = (b1 % 100) << 1;
 
 const uint32_t d7 = (c1 / 100) << 1;
 const uint32_t d8 = (c1 % 100) << 1;
 
 *buffer++ = cDigitsLut[d1];
 *buffer++ = cDigitsLut[d1 + 1];
 *buffer++ = cDigitsLut[d2];
 *buffer++ = cDigitsLut[d2 + 1];
 *buffer++ = cDigitsLut[d3];
 *buffer++ = cDigitsLut[d3 + 1];
 *buffer++ = cDigitsLut[d4];
 *buffer++ = cDigitsLut[d4 + 1];
 *buffer++ = cDigitsLut[d5];
 *buffer++ = cDigitsLut[d5 + 1];
 *buffer++ = cDigitsLut[d6];
 *buffer++ = cDigitsLut[d6 + 1];
 *buffer++ = cDigitsLut[d7];
 *buffer++ = cDigitsLut[d7 + 1];
 *buffer++ = cDigitsLut[d8];
 *buffer++ = cDigitsLut[d8 + 1];
 }
 
 return buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char* internal::WriteExponent ( int  K, char *  buffer  )

inline

 {
 if (K < 0) {
 *buffer++ = '-';
 K = -K;
 }

 if (K >= 100) {
 *buffer++ = static_cast<char>('0' + static_cast<char>(K / 100));
 K %= 100;
 const char* d = GetDigitsLut() + K * 2;
 *buffer++ = d[0];
 *buffer++ = d[1];
 }
 else if (K >= 10) {
 const char* d = GetDigitsLut() + K * 2;
 *buffer++ = d[0];
 *buffer++ = d[1];
 }
 else
 *buffer++ = static_cast<char>('0' + static_cast<char>(K));

 return buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function: