charconv.cc
Go to the documentation of this file.
1 // Copyright 2018 The Abseil Authors.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #include "absl/strings/charconv.h"
16 
17 #include <algorithm>
18 #include <cassert>
19 #include <cmath>
20 #include <cstring>
21 
22 #include "absl/base/casts.h"
24 #include "absl/numeric/int128.h"
27 
28 // The macro ABSL_BIT_PACK_FLOATS is defined on x86-64, where IEEE floating
29 // point numbers have the same endianness in memory as a bitfield struct
30 // containing the corresponding parts.
31 //
32 // When set, we replace calls to ldexp() with manual bit packing, which is
33 // faster and is unaffected by floating point environment.
34 #ifdef ABSL_BIT_PACK_FLOATS
35 #error ABSL_BIT_PACK_FLOATS cannot be directly set
36 #elif defined(__x86_64__) || defined(_M_X64)
37 #define ABSL_BIT_PACK_FLOATS 1
38 #endif
39 
40 // A note about subnormals:
41 //
42 // The code below talks about "normals" and "subnormals". A normal IEEE float
43 // has a fixed-width mantissa and power of two exponent. For example, a normal
44 // `double` has a 53-bit mantissa. Because the high bit is always 1, it is not
45 // stored in the representation. The implicit bit buys an extra bit of
46 // resolution in the datatype.
47 //
48 // The downside of this scheme is that there is a large gap between DBL_MIN and
49 // zero. (Large, at least, relative to the different between DBL_MIN and the
50 // next representable number). This gap is softened by the "subnormal" numbers,
51 // which have the same power-of-two exponent as DBL_MIN, but no implicit 53rd
52 // bit. An all-bits-zero exponent in the encoding represents subnormals. (Zero
53 // is represented as a subnormal with an all-bits-zero mantissa.)
54 //
55 // The code below, in calculations, represents the mantissa as a uint64_t. The
56 // end result normally has the 53rd bit set. It represents subnormals by using
57 // narrower mantissas.
58 
59 namespace absl {
60 namespace {
61 
62 template <typename FloatType>
63 struct FloatTraits;
64 
65 template <>
66 struct FloatTraits<double> {
67  // The number of mantissa bits in the given float type. This includes the
68  // implied high bit.
69  static constexpr int kTargetMantissaBits = 53;
70 
71  // The largest supported IEEE exponent, in our integral mantissa
72  // representation.
73  //
74  // If `m` is the largest possible int kTargetMantissaBits bits wide, then
75  // m * 2**kMaxExponent is exactly equal to DBL_MAX.
76  static constexpr int kMaxExponent = 971;
77 
78  // The smallest supported IEEE normal exponent, in our integral mantissa
79  // representation.
80  //
81  // If `m` is the smallest possible int kTargetMantissaBits bits wide, then
82  // m * 2**kMinNormalExponent is exactly equal to DBL_MIN.
83  static constexpr int kMinNormalExponent = -1074;
84 
85  static double MakeNan(const char* tagp) {
86  // Support nan no matter which namespace it's in. Some platforms
87  // incorrectly don't put it in namespace std.
88  using namespace std; // NOLINT
89  return nan(tagp);
90  }
91 
92  // Builds a nonzero floating point number out of the provided parts.
93  //
94  // This is intended to do the same operation as ldexp(mantissa, exponent),
95  // but using purely integer math, to avoid -ffastmath and floating
96  // point environment issues. Using type punning is also faster. We fall back
97  // to ldexp on a per-platform basis for portability.
98  //
99  // `exponent` must be between kMinNormalExponent and kMaxExponent.
100  //
101  // `mantissa` must either be exactly kTargetMantissaBits wide, in which case
102  // a normal value is made, or it must be less narrow than that, in which case
103  // `exponent` must be exactly kMinNormalExponent, and a subnormal value is
104  // made.
105  static double Make(uint64_t mantissa, int exponent, bool sign) {
106 #ifndef ABSL_BIT_PACK_FLOATS
107  // Support ldexp no matter which namespace it's in. Some platforms
108  // incorrectly don't put it in namespace std.
109  using namespace std; // NOLINT
110  return sign ? -ldexp(mantissa, exponent) : ldexp(mantissa, exponent);
111 #else
112  constexpr uint64_t kMantissaMask =
113  (uint64_t(1) << (kTargetMantissaBits - 1)) - 1;
114  uint64_t dbl = static_cast<uint64_t>(sign) << 63;
115  if (mantissa > kMantissaMask) {
116  // Normal value.
117  // Adjust by 1023 for the exponent representation bias, and an additional
118  // 52 due to the implied decimal point in the IEEE mantissa represenation.
119  dbl += uint64_t{exponent + 1023u + kTargetMantissaBits - 1} << 52;
120  mantissa &= kMantissaMask;
121  } else {
122  // subnormal value
123  assert(exponent == kMinNormalExponent);
124  }
125  dbl += mantissa;
126  return absl::bit_cast<double>(dbl);
127 #endif // ABSL_BIT_PACK_FLOATS
128  }
129 };
130 
131 // Specialization of floating point traits for the `float` type. See the
132 // FloatTraits<double> specialization above for meaning of each of the following
133 // members and methods.
134 template <>
135 struct FloatTraits<float> {
136  static constexpr int kTargetMantissaBits = 24;
137  static constexpr int kMaxExponent = 104;
138  static constexpr int kMinNormalExponent = -149;
139  static float MakeNan(const char* tagp) {
140  // Support nanf no matter which namespace it's in. Some platforms
141  // incorrectly don't put it in namespace std.
142  using namespace std; // NOLINT
143  return nanf(tagp);
144  }
145  static float Make(uint32_t mantissa, int exponent, bool sign) {
146 #ifndef ABSL_BIT_PACK_FLOATS
147  // Support ldexpf no matter which namespace it's in. Some platforms
148  // incorrectly don't put it in namespace std.
149  using namespace std; // NOLINT
150  return sign ? -ldexpf(mantissa, exponent) : ldexpf(mantissa, exponent);
151 #else
152  constexpr uint32_t kMantissaMask =
153  (uint32_t(1) << (kTargetMantissaBits - 1)) - 1;
154  uint32_t flt = static_cast<uint32_t>(sign) << 31;
155  if (mantissa > kMantissaMask) {
156  // Normal value.
157  // Adjust by 127 for the exponent representation bias, and an additional
158  // 23 due to the implied decimal point in the IEEE mantissa represenation.
159  flt += uint32_t{exponent + 127u + kTargetMantissaBits - 1} << 23;
160  mantissa &= kMantissaMask;
161  } else {
162  // subnormal value
163  assert(exponent == kMinNormalExponent);
164  }
165  flt += mantissa;
166  return absl::bit_cast<float>(flt);
167 #endif // ABSL_BIT_PACK_FLOATS
168  }
169 };
170 
171 // Decimal-to-binary conversions require coercing powers of 10 into a mantissa
172 // and a power of 2. The two helper functions Power10Mantissa(n) and
173 // Power10Exponent(n) perform this task. Together, these represent a hand-
174 // rolled floating point value which is equal to or just less than 10**n.
175 //
176 // The return values satisfy two range guarantees:
177 //
178 // Power10Mantissa(n) * 2**Power10Exponent(n) <= 10**n
179 // < (Power10Mantissa(n) + 1) * 2**Power10Exponent(n)
180 //
181 // 2**63 <= Power10Mantissa(n) < 2**64.
182 //
183 // Lookups into the power-of-10 table must first check the Power10Overflow() and
184 // Power10Underflow() functions, to avoid out-of-bounds table access.
185 //
186 // Indexes into these tables are biased by -kPower10TableMin, and the table has
187 // values in the range [kPower10TableMin, kPower10TableMax].
188 extern const uint64_t kPower10MantissaTable[];
189 extern const int16_t kPower10ExponentTable[];
190 
191 // The smallest allowed value for use with the Power10Mantissa() and
192 // Power10Exponent() functions below. (If a smaller exponent is needed in
193 // calculations, the end result is guaranteed to underflow.)
194 constexpr int kPower10TableMin = -342;
195 
196 // The largest allowed value for use with the Power10Mantissa() and
197 // Power10Exponent() functions below. (If a smaller exponent is needed in
198 // calculations, the end result is guaranteed to overflow.)
199 constexpr int kPower10TableMax = 308;
200 
201 uint64_t Power10Mantissa(int n) {
202  return kPower10MantissaTable[n - kPower10TableMin];
203 }
204 
205 int Power10Exponent(int n) {
206  return kPower10ExponentTable[n - kPower10TableMin];
207 }
208 
209 // Returns true if n is large enough that 10**n always results in an IEEE
210 // overflow.
211 bool Power10Overflow(int n) { return n > kPower10TableMax; }
212 
213 // Returns true if n is small enough that 10**n times a ParsedFloat mantissa
214 // always results in an IEEE underflow.
215 bool Power10Underflow(int n) { return n < kPower10TableMin; }
216 
217 // Returns true if Power10Mantissa(n) * 2**Power10Exponent(n) is exactly equal
218 // to 10**n numerically. Put another way, this returns true if there is no
219 // truncation error in Power10Mantissa(n).
220 bool Power10Exact(int n) { return n >= 0 && n <= 27; }
221 
222 // Sentinel exponent values for representing numbers too large or too close to
223 // zero to represent in a double.
224 constexpr int kOverflow = 99999;
225 constexpr int kUnderflow = -99999;
226 
227 // Struct representing the calculated conversion result of a positive (nonzero)
228 // floating point number.
229 //
230 // The calculated number is mantissa * 2**exponent (mantissa is treated as an
231 // integer.) `mantissa` is chosen to be the correct width for the IEEE float
232 // representation being calculated. (`mantissa` will always have the same bit
233 // width for normal values, and narrower bit widths for subnormals.)
234 //
235 // If the result of conversion was an underflow or overflow, exponent is set
236 // to kUnderflow or kOverflow.
237 struct CalculatedFloat {
238  uint64_t mantissa = 0;
239  int exponent = 0;
240 };
241 
242 // Returns the bit width of the given uint128. (Equivalently, returns 128
243 // minus the number of leading zero bits.)
244 int BitWidth(uint128 value) {
245  if (Uint128High64(value) == 0) {
247  }
249 }
250 
251 // Calculates how far to the right a mantissa needs to be shifted to create a
252 // properly adjusted mantissa for an IEEE floating point number.
253 //
254 // `mantissa_width` is the bit width of the mantissa to be shifted, and
255 // `binary_exponent` is the exponent of the number before the shift.
256 //
257 // This accounts for subnormal values, and will return a larger-than-normal
258 // shift if binary_exponent would otherwise be too low.
259 template <typename FloatType>
260 int NormalizedShiftSize(int mantissa_width, int binary_exponent) {
261  const int normal_shift =
262  mantissa_width - FloatTraits<FloatType>::kTargetMantissaBits;
263  const int minimum_shift =
264  FloatTraits<FloatType>::kMinNormalExponent - binary_exponent;
265  return std::max(normal_shift, minimum_shift);
266 }
267 
268 // Right shifts a uint128 so that it has the requested bit width. (The
269 // resulting value will have 128 - bit_width leading zeroes.) The initial
270 // `value` must be wider than the requested bit width.
271 //
272 // Returns the number of bits shifted.
273 int TruncateToBitWidth(int bit_width, uint128* value) {
274  const int current_bit_width = BitWidth(*value);
275  const int shift = current_bit_width - bit_width;
276  *value >>= shift;
277  return shift;
278 }
279 
280 // Checks if the given ParsedFloat represents one of the edge cases that are
281 // not dependent on number base: zero, infinity, or NaN. If so, sets *value
282 // the appropriate double, and returns true.
283 template <typename FloatType>
284 bool HandleEdgeCase(const strings_internal::ParsedFloat& input, bool negative,
285  FloatType* value) {
286  if (input.type == strings_internal::FloatType::kNan) {
287  // A bug in both clang and gcc would cause the compiler to optimize away the
288  // buffer we are building below. Declaring the buffer volatile avoids the
289  // issue, and has no measurable performance impact in microbenchmarks.
290  //
291  // https://bugs.llvm.org/show_bug.cgi?id=37778
292  // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86113
293  constexpr ptrdiff_t kNanBufferSize = 128;
294  volatile char n_char_sequence[kNanBufferSize];
295  if (input.subrange_begin == nullptr) {
296  n_char_sequence[0] = '\0';
297  } else {
298  ptrdiff_t nan_size = input.subrange_end - input.subrange_begin;
299  nan_size = std::min(nan_size, kNanBufferSize - 1);
300  std::copy_n(input.subrange_begin, nan_size, n_char_sequence);
301  n_char_sequence[nan_size] = '\0';
302  }
303  char* nan_argument = const_cast<char*>(n_char_sequence);
304  *value = negative ? -FloatTraits<FloatType>::MakeNan(nan_argument)
305  : FloatTraits<FloatType>::MakeNan(nan_argument);
306  return true;
307  }
308  if (input.type == strings_internal::FloatType::kInfinity) {
309  *value = negative ? -std::numeric_limits<FloatType>::infinity()
310  : std::numeric_limits<FloatType>::infinity();
311  return true;
312  }
313  if (input.mantissa == 0) {
314  *value = negative ? -0.0 : 0.0;
315  return true;
316  }
317  return false;
318 }
319 
320 // Given a CalculatedFloat result of a from_chars conversion, generate the
321 // correct output values.
322 //
323 // CalculatedFloat can represent an underflow or overflow, in which case the
324 // error code in *result is set. Otherwise, the calculated floating point
325 // number is stored in *value.
326 template <typename FloatType>
327 void EncodeResult(const CalculatedFloat& calculated, bool negative,
328  absl::from_chars_result* result, FloatType* value) {
329  if (calculated.exponent == kOverflow) {
330  result->ec = std::errc::result_out_of_range;
331  *value = negative ? -std::numeric_limits<FloatType>::max()
332  : std::numeric_limits<FloatType>::max();
333  return;
334  } else if (calculated.mantissa == 0 || calculated.exponent == kUnderflow) {
335  result->ec = std::errc::result_out_of_range;
336  *value = negative ? -0.0 : 0.0;
337  return;
338  }
339  *value = FloatTraits<FloatType>::Make(calculated.mantissa,
340  calculated.exponent, negative);
341 }
342 
343 // Returns the given uint128 shifted to the right by `shift` bits, and rounds
344 // the remaining bits using round_to_nearest logic. The value is returned as a
345 // uint64_t, since this is the type used by this library for storing calculated
346 // floating point mantissas.
347 //
348 // It is expected that the width of the input value shifted by `shift` will
349 // be the correct bit-width for the target mantissa, which is strictly narrower
350 // than a uint64_t.
351 //
352 // If `input_exact` is false, then a nonzero error epsilon is assumed. For
353 // rounding purposes, the true value being rounded is strictly greater than the
354 // input value. The error may represent a single lost carry bit.
355 //
356 // When input_exact, shifted bits of the form 1000000... represent a tie, which
357 // is broken by rounding to even -- the rounding direction is chosen so the low
358 // bit of the returned value is 0.
359 //
360 // When !input_exact, shifted bits of the form 10000000... represent a value
361 // strictly greater than one half (due to the error epsilon), and so ties are
362 // always broken by rounding up.
363 //
364 // When !input_exact, shifted bits of the form 01111111... are uncertain;
365 // the true value may or may not be greater than 10000000..., due to the
366 // possible lost carry bit. The correct rounding direction is unknown. In this
367 // case, the result is rounded down, and `output_exact` is set to false.
368 //
369 // Zero and negative values of `shift` are accepted, in which case the word is
370 // shifted left, as necessary.
371 uint64_t ShiftRightAndRound(uint128 value, int shift, bool input_exact,
372  bool* output_exact) {
373  if (shift <= 0) {
374  *output_exact = input_exact;
375  return static_cast<uint64_t>(value << -shift);
376  }
377  if (shift >= 128) {
378  // Exponent is so small that we are shifting away all significant bits.
379  // Answer will not be representable, even as a subnormal, so return a zero
380  // mantissa (which represents underflow).
381  *output_exact = true;
382  return 0;
383  }
384 
385  *output_exact = true;
386  const uint128 shift_mask = (uint128(1) << shift) - 1;
387  const uint128 halfway_point = uint128(1) << (shift - 1);
388 
389  const uint128 shifted_bits = value & shift_mask;
390  value >>= shift;
391  if (shifted_bits > halfway_point) {
392  // Shifted bits greater than 10000... require rounding up.
393  return static_cast<uint64_t>(value + 1);
394  }
395  if (shifted_bits == halfway_point) {
396  // In exact mode, shifted bits of 10000... mean we're exactly halfway
397  // between two numbers, and we must round to even. So only round up if
398  // the low bit of `value` is set.
399  //
400  // In inexact mode, the nonzero error means the actual value is greater
401  // than the halfway point and we must alway round up.
402  if ((value & 1) == 1 || !input_exact) {
403  ++value;
404  }
405  return static_cast<uint64_t>(value);
406  }
407  if (!input_exact && shifted_bits == halfway_point - 1) {
408  // Rounding direction is unclear, due to error.
409  *output_exact = false;
410  }
411  // Otherwise, round down.
412  return static_cast<uint64_t>(value);
413 }
414 
415 // Checks if a floating point guess needs to be rounded up, using high precision
416 // math.
417 //
418 // `guess_mantissa` and `guess_exponent` represent a candidate guess for the
419 // number represented by `parsed_decimal`.
420 //
421 // The exact number represented by `parsed_decimal` must lie between the two
422 // numbers:
423 // A = `guess_mantissa * 2**guess_exponent`
424 // B = `(guess_mantissa + 1) * 2**guess_exponent`
425 //
426 // This function returns false if `A` is the better guess, and true if `B` is
427 // the better guess, with rounding ties broken by rounding to even.
428 bool MustRoundUp(uint64_t guess_mantissa, int guess_exponent,
429  const strings_internal::ParsedFloat& parsed_decimal) {
430  // 768 is the number of digits needed in the worst case. We could determine a
431  // better limit dynamically based on the value of parsed_decimal.exponent.
432  // This would optimize pathological input cases only. (Sane inputs won't have
433  // hundreds of digits of mantissa.)
435  int exact_exponent = exact_mantissa.ReadFloatMantissa(parsed_decimal, 768);
436 
437  // Adjust the `guess` arguments to be halfway between A and B.
438  guess_mantissa = guess_mantissa * 2 + 1;
439  guess_exponent -= 1;
440 
441  // In our comparison:
442  // lhs = exact = exact_mantissa * 10**exact_exponent
443  // = exact_mantissa * 5**exact_exponent * 2**exact_exponent
444  // rhs = guess = guess_mantissa * 2**guess_exponent
445  //
446  // Because we are doing integer math, we can't directly deal with negative
447  // exponents. We instead move these to the other side of the inequality.
448  absl::strings_internal::BigUnsigned<84>& lhs = exact_mantissa;
449  int comparison;
450  if (exact_exponent >= 0) {
451  lhs.MultiplyByFiveToTheNth(exact_exponent);
452  absl::strings_internal::BigUnsigned<84> rhs(guess_mantissa);
453  // There are powers of 2 on both sides of the inequality; reduce this to
454  // a single bit-shift.
455  if (exact_exponent > guess_exponent) {
456  lhs.ShiftLeft(exact_exponent - guess_exponent);
457  } else {
458  rhs.ShiftLeft(guess_exponent - exact_exponent);
459  }
460  comparison = Compare(lhs, rhs);
461  } else {
462  // Move the power of 5 to the other side of the equation, giving us:
463  // lhs = exact_mantissa * 2**exact_exponent
464  // rhs = guess_mantissa * 5**(-exact_exponent) * 2**guess_exponent
467  rhs.MultiplyBy(guess_mantissa);
468  if (exact_exponent > guess_exponent) {
469  lhs.ShiftLeft(exact_exponent - guess_exponent);
470  } else {
471  rhs.ShiftLeft(guess_exponent - exact_exponent);
472  }
473  comparison = Compare(lhs, rhs);
474  }
475  if (comparison < 0) {
476  return false;
477  } else if (comparison > 0) {
478  return true;
479  } else {
480  // When lhs == rhs, the decimal input is exactly between A and B.
481  // Round towards even -- round up only if the low bit of the initial
482  // `guess_mantissa` was a 1. We shifted guess_mantissa left 1 bit at
483  // the beginning of this function, so test the 2nd bit here.
484  return (guess_mantissa & 2) == 2;
485  }
486 }
487 
488 // Constructs a CalculatedFloat from a given mantissa and exponent, but
489 // with the following normalizations applied:
490 //
491 // If rounding has caused mantissa to increase just past the allowed bit
492 // width, shift and adjust exponent.
493 //
494 // If exponent is too high, sets kOverflow.
495 //
496 // If mantissa is zero (representing a non-zero value not representable, even
497 // as a subnormal), sets kUnderflow.
498 template <typename FloatType>
499 CalculatedFloat CalculatedFloatFromRawValues(uint64_t mantissa, int exponent) {
500  CalculatedFloat result;
501  if (mantissa == uint64_t(1) << FloatTraits<FloatType>::kTargetMantissaBits) {
502  mantissa >>= 1;
503  exponent += 1;
504  }
505  if (exponent > FloatTraits<FloatType>::kMaxExponent) {
506  result.exponent = kOverflow;
507  } else if (mantissa == 0) {
508  result.exponent = kUnderflow;
509  } else {
510  result.exponent = exponent;
511  result.mantissa = mantissa;
512  }
513  return result;
514 }
515 
516 template <typename FloatType>
517 CalculatedFloat CalculateFromParsedHexadecimal(
518  const strings_internal::ParsedFloat& parsed_hex) {
519  uint64_t mantissa = parsed_hex.mantissa;
520  int exponent = parsed_hex.exponent;
521  int mantissa_width = 64 - base_internal::CountLeadingZeros64(mantissa);
522  const int shift = NormalizedShiftSize<FloatType>(mantissa_width, exponent);
523  bool result_exact;
524  exponent += shift;
525  mantissa = ShiftRightAndRound(mantissa, shift,
526  /* input exact= */ true, &result_exact);
527  // ParseFloat handles rounding in the hexadecimal case, so we don't have to
528  // check `result_exact` here.
529  return CalculatedFloatFromRawValues<FloatType>(mantissa, exponent);
530 }
531 
532 template <typename FloatType>
533 CalculatedFloat CalculateFromParsedDecimal(
534  const strings_internal::ParsedFloat& parsed_decimal) {
535  CalculatedFloat result;
536 
537  // Large or small enough decimal exponents will always result in overflow
538  // or underflow.
539  if (Power10Underflow(parsed_decimal.exponent)) {
540  result.exponent = kUnderflow;
541  return result;
542  } else if (Power10Overflow(parsed_decimal.exponent)) {
543  result.exponent = kOverflow;
544  return result;
545  }
546 
547  // Otherwise convert our power of 10 into a power of 2 times an integer
548  // mantissa, and multiply this by our parsed decimal mantissa.
549  uint128 wide_binary_mantissa = parsed_decimal.mantissa;
550  wide_binary_mantissa *= Power10Mantissa(parsed_decimal.exponent);
551  int binary_exponent = Power10Exponent(parsed_decimal.exponent);
552 
553  // Discard bits that are inaccurate due to truncation error. The magic
554  // `mantissa_width` constants below are justified in
555  // https://abseil.io/about/design/charconv. They represent the number of bits
556  // in `wide_binary_mantissa` that are guaranteed to be unaffected by error
557  // propagation.
558  bool mantissa_exact;
559  int mantissa_width;
560  if (parsed_decimal.subrange_begin) {
561  // Truncated mantissa
562  mantissa_width = 58;
563  mantissa_exact = false;
564  binary_exponent +=
565  TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
566  } else if (!Power10Exact(parsed_decimal.exponent)) {
567  // Exact mantissa, truncated power of ten
568  mantissa_width = 63;
569  mantissa_exact = false;
570  binary_exponent +=
571  TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
572  } else {
573  // Product is exact
574  mantissa_width = BitWidth(wide_binary_mantissa);
575  mantissa_exact = true;
576  }
577 
578  // Shift into an FloatType-sized mantissa, and round to nearest.
579  const int shift =
580  NormalizedShiftSize<FloatType>(mantissa_width, binary_exponent);
581  bool result_exact;
582  binary_exponent += shift;
583  uint64_t binary_mantissa = ShiftRightAndRound(wide_binary_mantissa, shift,
584  mantissa_exact, &result_exact);
585  if (!result_exact) {
586  // We could not determine the rounding direction using int128 math. Use
587  // full resolution math instead.
588  if (MustRoundUp(binary_mantissa, binary_exponent, parsed_decimal)) {
589  binary_mantissa += 1;
590  }
591  }
592 
593  return CalculatedFloatFromRawValues<FloatType>(binary_mantissa,
594  binary_exponent);
595 }
596 
597 template <typename FloatType>
598 from_chars_result FromCharsImpl(const char* first, const char* last,
599  FloatType& value, chars_format fmt_flags) {
600  from_chars_result result;
601  result.ptr = first; // overwritten on successful parse
602  result.ec = std::errc();
603 
604  bool negative = false;
605  if (first != last && *first == '-') {
606  ++first;
607  negative = true;
608  }
609  // If the `hex` flag is *not* set, then we will accept a 0x prefix and try
610  // to parse a hexadecimal float.
611  if ((fmt_flags & chars_format::hex) == chars_format{} && last - first >= 2 &&
612  *first == '0' && (first[1] == 'x' || first[1] == 'X')) {
613  const char* hex_first = first + 2;
614  strings_internal::ParsedFloat hex_parse =
615  strings_internal::ParseFloat<16>(hex_first, last, fmt_flags);
616  if (hex_parse.end == nullptr ||
617  hex_parse.type != strings_internal::FloatType::kNumber) {
618  // Either we failed to parse a hex float after the "0x", or we read
619  // "0xinf" or "0xnan" which we don't want to match.
620  //
621  // However, a std::string that begins with "0x" also begins with "0", which
622  // is normally a valid match for the number zero. So we want these
623  // strings to match zero unless fmt_flags is `scientific`. (This flag
624  // means an exponent is required, which the std::string "0" does not have.)
625  if (fmt_flags == chars_format::scientific) {
626  result.ec = std::errc::invalid_argument;
627  } else {
628  result.ptr = first + 1;
629  value = negative ? -0.0 : 0.0;
630  }
631  return result;
632  }
633  // We matched a value.
634  result.ptr = hex_parse.end;
635  if (HandleEdgeCase(hex_parse, negative, &value)) {
636  return result;
637  }
638  CalculatedFloat calculated =
639  CalculateFromParsedHexadecimal<FloatType>(hex_parse);
640  EncodeResult(calculated, negative, &result, &value);
641  return result;
642  }
643  // Otherwise, we choose the number base based on the flags.
644  if ((fmt_flags & chars_format::hex) == chars_format::hex) {
645  strings_internal::ParsedFloat hex_parse =
646  strings_internal::ParseFloat<16>(first, last, fmt_flags);
647  if (hex_parse.end == nullptr) {
648  result.ec = std::errc::invalid_argument;
649  return result;
650  }
651  result.ptr = hex_parse.end;
652  if (HandleEdgeCase(hex_parse, negative, &value)) {
653  return result;
654  }
655  CalculatedFloat calculated =
656  CalculateFromParsedHexadecimal<FloatType>(hex_parse);
657  EncodeResult(calculated, negative, &result, &value);
658  return result;
659  } else {
660  strings_internal::ParsedFloat decimal_parse =
661  strings_internal::ParseFloat<10>(first, last, fmt_flags);
662  if (decimal_parse.end == nullptr) {
663  result.ec = std::errc::invalid_argument;
664  return result;
665  }
666  result.ptr = decimal_parse.end;
667  if (HandleEdgeCase(decimal_parse, negative, &value)) {
668  return result;
669  }
670  CalculatedFloat calculated =
671  CalculateFromParsedDecimal<FloatType>(decimal_parse);
672  EncodeResult(calculated, negative, &result, &value);
673  return result;
674  }
675  return result;
676 }
677 } // namespace
678 
679 from_chars_result from_chars(const char* first, const char* last, double& value,
680  chars_format fmt) {
681  return FromCharsImpl(first, last, value, fmt);
682 }
683 
684 from_chars_result from_chars(const char* first, const char* last, float& value,
685  chars_format fmt) {
686  return FromCharsImpl(first, last, value, fmt);
687 }
688 
689 namespace {
690 
691 // Table of powers of 10, from kPower10TableMin to kPower10TableMax.
692 //
693 // kPower10MantissaTable[i - kPower10TableMin] stores the 64-bit mantissa (high
694 // bit always on), and kPower10ExponentTable[i - kPower10TableMin] stores the
695 // power-of-two exponent. For a given number i, this gives the unique mantissa
696 // and exponent such that mantissa * 2**exponent <= 10**i < (mantissa + 1) *
697 // 2**exponent.
698 
699 const uint64_t kPower10MantissaTable[] = {
700  0xeef453d6923bd65aU, 0x9558b4661b6565f8U, 0xbaaee17fa23ebf76U,
701  0xe95a99df8ace6f53U, 0x91d8a02bb6c10594U, 0xb64ec836a47146f9U,
702  0xe3e27a444d8d98b7U, 0x8e6d8c6ab0787f72U, 0xb208ef855c969f4fU,
703  0xde8b2b66b3bc4723U, 0x8b16fb203055ac76U, 0xaddcb9e83c6b1793U,
704  0xd953e8624b85dd78U, 0x87d4713d6f33aa6bU, 0xa9c98d8ccb009506U,
705  0xd43bf0effdc0ba48U, 0x84a57695fe98746dU, 0xa5ced43b7e3e9188U,
706  0xcf42894a5dce35eaU, 0x818995ce7aa0e1b2U, 0xa1ebfb4219491a1fU,
707  0xca66fa129f9b60a6U, 0xfd00b897478238d0U, 0x9e20735e8cb16382U,
708  0xc5a890362fddbc62U, 0xf712b443bbd52b7bU, 0x9a6bb0aa55653b2dU,
709  0xc1069cd4eabe89f8U, 0xf148440a256e2c76U, 0x96cd2a865764dbcaU,
710  0xbc807527ed3e12bcU, 0xeba09271e88d976bU, 0x93445b8731587ea3U,
711  0xb8157268fdae9e4cU, 0xe61acf033d1a45dfU, 0x8fd0c16206306babU,
712  0xb3c4f1ba87bc8696U, 0xe0b62e2929aba83cU, 0x8c71dcd9ba0b4925U,
713  0xaf8e5410288e1b6fU, 0xdb71e91432b1a24aU, 0x892731ac9faf056eU,
714  0xab70fe17c79ac6caU, 0xd64d3d9db981787dU, 0x85f0468293f0eb4eU,
715  0xa76c582338ed2621U, 0xd1476e2c07286faaU, 0x82cca4db847945caU,
716  0xa37fce126597973cU, 0xcc5fc196fefd7d0cU, 0xff77b1fcbebcdc4fU,
717  0x9faacf3df73609b1U, 0xc795830d75038c1dU, 0xf97ae3d0d2446f25U,
718  0x9becce62836ac577U, 0xc2e801fb244576d5U, 0xf3a20279ed56d48aU,
719  0x9845418c345644d6U, 0xbe5691ef416bd60cU, 0xedec366b11c6cb8fU,
720  0x94b3a202eb1c3f39U, 0xb9e08a83a5e34f07U, 0xe858ad248f5c22c9U,
721  0x91376c36d99995beU, 0xb58547448ffffb2dU, 0xe2e69915b3fff9f9U,
722  0x8dd01fad907ffc3bU, 0xb1442798f49ffb4aU, 0xdd95317f31c7fa1dU,
723  0x8a7d3eef7f1cfc52U, 0xad1c8eab5ee43b66U, 0xd863b256369d4a40U,
724  0x873e4f75e2224e68U, 0xa90de3535aaae202U, 0xd3515c2831559a83U,
725  0x8412d9991ed58091U, 0xa5178fff668ae0b6U, 0xce5d73ff402d98e3U,
726  0x80fa687f881c7f8eU, 0xa139029f6a239f72U, 0xc987434744ac874eU,
727  0xfbe9141915d7a922U, 0x9d71ac8fada6c9b5U, 0xc4ce17b399107c22U,
728  0xf6019da07f549b2bU, 0x99c102844f94e0fbU, 0xc0314325637a1939U,
729  0xf03d93eebc589f88U, 0x96267c7535b763b5U, 0xbbb01b9283253ca2U,
730  0xea9c227723ee8bcbU, 0x92a1958a7675175fU, 0xb749faed14125d36U,
731  0xe51c79a85916f484U, 0x8f31cc0937ae58d2U, 0xb2fe3f0b8599ef07U,
732  0xdfbdcece67006ac9U, 0x8bd6a141006042bdU, 0xaecc49914078536dU,
733  0xda7f5bf590966848U, 0x888f99797a5e012dU, 0xaab37fd7d8f58178U,
734  0xd5605fcdcf32e1d6U, 0x855c3be0a17fcd26U, 0xa6b34ad8c9dfc06fU,
735  0xd0601d8efc57b08bU, 0x823c12795db6ce57U, 0xa2cb1717b52481edU,
736  0xcb7ddcdda26da268U, 0xfe5d54150b090b02U, 0x9efa548d26e5a6e1U,
737  0xc6b8e9b0709f109aU, 0xf867241c8cc6d4c0U, 0x9b407691d7fc44f8U,
738  0xc21094364dfb5636U, 0xf294b943e17a2bc4U, 0x979cf3ca6cec5b5aU,
739  0xbd8430bd08277231U, 0xece53cec4a314ebdU, 0x940f4613ae5ed136U,
740  0xb913179899f68584U, 0xe757dd7ec07426e5U, 0x9096ea6f3848984fU,
741  0xb4bca50b065abe63U, 0xe1ebce4dc7f16dfbU, 0x8d3360f09cf6e4bdU,
742  0xb080392cc4349decU, 0xdca04777f541c567U, 0x89e42caaf9491b60U,
743  0xac5d37d5b79b6239U, 0xd77485cb25823ac7U, 0x86a8d39ef77164bcU,
744  0xa8530886b54dbdebU, 0xd267caa862a12d66U, 0x8380dea93da4bc60U,
745  0xa46116538d0deb78U, 0xcd795be870516656U, 0x806bd9714632dff6U,
746  0xa086cfcd97bf97f3U, 0xc8a883c0fdaf7df0U, 0xfad2a4b13d1b5d6cU,
747  0x9cc3a6eec6311a63U, 0xc3f490aa77bd60fcU, 0xf4f1b4d515acb93bU,
748  0x991711052d8bf3c5U, 0xbf5cd54678eef0b6U, 0xef340a98172aace4U,
749  0x9580869f0e7aac0eU, 0xbae0a846d2195712U, 0xe998d258869facd7U,
750  0x91ff83775423cc06U, 0xb67f6455292cbf08U, 0xe41f3d6a7377eecaU,
751  0x8e938662882af53eU, 0xb23867fb2a35b28dU, 0xdec681f9f4c31f31U,
752  0x8b3c113c38f9f37eU, 0xae0b158b4738705eU, 0xd98ddaee19068c76U,
753  0x87f8a8d4cfa417c9U, 0xa9f6d30a038d1dbcU, 0xd47487cc8470652bU,
754  0x84c8d4dfd2c63f3bU, 0xa5fb0a17c777cf09U, 0xcf79cc9db955c2ccU,
755  0x81ac1fe293d599bfU, 0xa21727db38cb002fU, 0xca9cf1d206fdc03bU,
756  0xfd442e4688bd304aU, 0x9e4a9cec15763e2eU, 0xc5dd44271ad3cdbaU,
757  0xf7549530e188c128U, 0x9a94dd3e8cf578b9U, 0xc13a148e3032d6e7U,
758  0xf18899b1bc3f8ca1U, 0x96f5600f15a7b7e5U, 0xbcb2b812db11a5deU,
759  0xebdf661791d60f56U, 0x936b9fcebb25c995U, 0xb84687c269ef3bfbU,
760  0xe65829b3046b0afaU, 0x8ff71a0fe2c2e6dcU, 0xb3f4e093db73a093U,
761  0xe0f218b8d25088b8U, 0x8c974f7383725573U, 0xafbd2350644eeacfU,
762  0xdbac6c247d62a583U, 0x894bc396ce5da772U, 0xab9eb47c81f5114fU,
763  0xd686619ba27255a2U, 0x8613fd0145877585U, 0xa798fc4196e952e7U,
764  0xd17f3b51fca3a7a0U, 0x82ef85133de648c4U, 0xa3ab66580d5fdaf5U,
765  0xcc963fee10b7d1b3U, 0xffbbcfe994e5c61fU, 0x9fd561f1fd0f9bd3U,
766  0xc7caba6e7c5382c8U, 0xf9bd690a1b68637bU, 0x9c1661a651213e2dU,
767  0xc31bfa0fe5698db8U, 0xf3e2f893dec3f126U, 0x986ddb5c6b3a76b7U,
768  0xbe89523386091465U, 0xee2ba6c0678b597fU, 0x94db483840b717efU,
769  0xba121a4650e4ddebU, 0xe896a0d7e51e1566U, 0x915e2486ef32cd60U,
770  0xb5b5ada8aaff80b8U, 0xe3231912d5bf60e6U, 0x8df5efabc5979c8fU,
771  0xb1736b96b6fd83b3U, 0xddd0467c64bce4a0U, 0x8aa22c0dbef60ee4U,
772  0xad4ab7112eb3929dU, 0xd89d64d57a607744U, 0x87625f056c7c4a8bU,
773  0xa93af6c6c79b5d2dU, 0xd389b47879823479U, 0x843610cb4bf160cbU,
774  0xa54394fe1eedb8feU, 0xce947a3da6a9273eU, 0x811ccc668829b887U,
775  0xa163ff802a3426a8U, 0xc9bcff6034c13052U, 0xfc2c3f3841f17c67U,
776  0x9d9ba7832936edc0U, 0xc5029163f384a931U, 0xf64335bcf065d37dU,
777  0x99ea0196163fa42eU, 0xc06481fb9bcf8d39U, 0xf07da27a82c37088U,
778  0x964e858c91ba2655U, 0xbbe226efb628afeaU, 0xeadab0aba3b2dbe5U,
779  0x92c8ae6b464fc96fU, 0xb77ada0617e3bbcbU, 0xe55990879ddcaabdU,
780  0x8f57fa54c2a9eab6U, 0xb32df8e9f3546564U, 0xdff9772470297ebdU,
781  0x8bfbea76c619ef36U, 0xaefae51477a06b03U, 0xdab99e59958885c4U,
782  0x88b402f7fd75539bU, 0xaae103b5fcd2a881U, 0xd59944a37c0752a2U,
783  0x857fcae62d8493a5U, 0xa6dfbd9fb8e5b88eU, 0xd097ad07a71f26b2U,
784  0x825ecc24c873782fU, 0xa2f67f2dfa90563bU, 0xcbb41ef979346bcaU,
785  0xfea126b7d78186bcU, 0x9f24b832e6b0f436U, 0xc6ede63fa05d3143U,
786  0xf8a95fcf88747d94U, 0x9b69dbe1b548ce7cU, 0xc24452da229b021bU,
787  0xf2d56790ab41c2a2U, 0x97c560ba6b0919a5U, 0xbdb6b8e905cb600fU,
788  0xed246723473e3813U, 0x9436c0760c86e30bU, 0xb94470938fa89bceU,
789  0xe7958cb87392c2c2U, 0x90bd77f3483bb9b9U, 0xb4ecd5f01a4aa828U,
790  0xe2280b6c20dd5232U, 0x8d590723948a535fU, 0xb0af48ec79ace837U,
791  0xdcdb1b2798182244U, 0x8a08f0f8bf0f156bU, 0xac8b2d36eed2dac5U,
792  0xd7adf884aa879177U, 0x86ccbb52ea94baeaU, 0xa87fea27a539e9a5U,
793  0xd29fe4b18e88640eU, 0x83a3eeeef9153e89U, 0xa48ceaaab75a8e2bU,
794  0xcdb02555653131b6U, 0x808e17555f3ebf11U, 0xa0b19d2ab70e6ed6U,
795  0xc8de047564d20a8bU, 0xfb158592be068d2eU, 0x9ced737bb6c4183dU,
796  0xc428d05aa4751e4cU, 0xf53304714d9265dfU, 0x993fe2c6d07b7fabU,
797  0xbf8fdb78849a5f96U, 0xef73d256a5c0f77cU, 0x95a8637627989aadU,
798  0xbb127c53b17ec159U, 0xe9d71b689dde71afU, 0x9226712162ab070dU,
799  0xb6b00d69bb55c8d1U, 0xe45c10c42a2b3b05U, 0x8eb98a7a9a5b04e3U,
800  0xb267ed1940f1c61cU, 0xdf01e85f912e37a3U, 0x8b61313bbabce2c6U,
801  0xae397d8aa96c1b77U, 0xd9c7dced53c72255U, 0x881cea14545c7575U,
802  0xaa242499697392d2U, 0xd4ad2dbfc3d07787U, 0x84ec3c97da624ab4U,
803  0xa6274bbdd0fadd61U, 0xcfb11ead453994baU, 0x81ceb32c4b43fcf4U,
804  0xa2425ff75e14fc31U, 0xcad2f7f5359a3b3eU, 0xfd87b5f28300ca0dU,
805  0x9e74d1b791e07e48U, 0xc612062576589ddaU, 0xf79687aed3eec551U,
806  0x9abe14cd44753b52U, 0xc16d9a0095928a27U, 0xf1c90080baf72cb1U,
807  0x971da05074da7beeU, 0xbce5086492111aeaU, 0xec1e4a7db69561a5U,
808  0x9392ee8e921d5d07U, 0xb877aa3236a4b449U, 0xe69594bec44de15bU,
809  0x901d7cf73ab0acd9U, 0xb424dc35095cd80fU, 0xe12e13424bb40e13U,
810  0x8cbccc096f5088cbU, 0xafebff0bcb24aafeU, 0xdbe6fecebdedd5beU,
811  0x89705f4136b4a597U, 0xabcc77118461cefcU, 0xd6bf94d5e57a42bcU,
812  0x8637bd05af6c69b5U, 0xa7c5ac471b478423U, 0xd1b71758e219652bU,
813  0x83126e978d4fdf3bU, 0xa3d70a3d70a3d70aU, 0xccccccccccccccccU,
814  0x8000000000000000U, 0xa000000000000000U, 0xc800000000000000U,
815  0xfa00000000000000U, 0x9c40000000000000U, 0xc350000000000000U,
816  0xf424000000000000U, 0x9896800000000000U, 0xbebc200000000000U,
817  0xee6b280000000000U, 0x9502f90000000000U, 0xba43b74000000000U,
818  0xe8d4a51000000000U, 0x9184e72a00000000U, 0xb5e620f480000000U,
819  0xe35fa931a0000000U, 0x8e1bc9bf04000000U, 0xb1a2bc2ec5000000U,
820  0xde0b6b3a76400000U, 0x8ac7230489e80000U, 0xad78ebc5ac620000U,
821  0xd8d726b7177a8000U, 0x878678326eac9000U, 0xa968163f0a57b400U,
822  0xd3c21bcecceda100U, 0x84595161401484a0U, 0xa56fa5b99019a5c8U,
823  0xcecb8f27f4200f3aU, 0x813f3978f8940984U, 0xa18f07d736b90be5U,
824  0xc9f2c9cd04674edeU, 0xfc6f7c4045812296U, 0x9dc5ada82b70b59dU,
825  0xc5371912364ce305U, 0xf684df56c3e01bc6U, 0x9a130b963a6c115cU,
826  0xc097ce7bc90715b3U, 0xf0bdc21abb48db20U, 0x96769950b50d88f4U,
827  0xbc143fa4e250eb31U, 0xeb194f8e1ae525fdU, 0x92efd1b8d0cf37beU,
828  0xb7abc627050305adU, 0xe596b7b0c643c719U, 0x8f7e32ce7bea5c6fU,
829  0xb35dbf821ae4f38bU, 0xe0352f62a19e306eU, 0x8c213d9da502de45U,
830  0xaf298d050e4395d6U, 0xdaf3f04651d47b4cU, 0x88d8762bf324cd0fU,
831  0xab0e93b6efee0053U, 0xd5d238a4abe98068U, 0x85a36366eb71f041U,
832  0xa70c3c40a64e6c51U, 0xd0cf4b50cfe20765U, 0x82818f1281ed449fU,
833  0xa321f2d7226895c7U, 0xcbea6f8ceb02bb39U, 0xfee50b7025c36a08U,
834  0x9f4f2726179a2245U, 0xc722f0ef9d80aad6U, 0xf8ebad2b84e0d58bU,
835  0x9b934c3b330c8577U, 0xc2781f49ffcfa6d5U, 0xf316271c7fc3908aU,
836  0x97edd871cfda3a56U, 0xbde94e8e43d0c8ecU, 0xed63a231d4c4fb27U,
837  0x945e455f24fb1cf8U, 0xb975d6b6ee39e436U, 0xe7d34c64a9c85d44U,
838  0x90e40fbeea1d3a4aU, 0xb51d13aea4a488ddU, 0xe264589a4dcdab14U,
839  0x8d7eb76070a08aecU, 0xb0de65388cc8ada8U, 0xdd15fe86affad912U,
840  0x8a2dbf142dfcc7abU, 0xacb92ed9397bf996U, 0xd7e77a8f87daf7fbU,
841  0x86f0ac99b4e8dafdU, 0xa8acd7c0222311bcU, 0xd2d80db02aabd62bU,
842  0x83c7088e1aab65dbU, 0xa4b8cab1a1563f52U, 0xcde6fd5e09abcf26U,
843  0x80b05e5ac60b6178U, 0xa0dc75f1778e39d6U, 0xc913936dd571c84cU,
844  0xfb5878494ace3a5fU, 0x9d174b2dcec0e47bU, 0xc45d1df942711d9aU,
845  0xf5746577930d6500U, 0x9968bf6abbe85f20U, 0xbfc2ef456ae276e8U,
846  0xefb3ab16c59b14a2U, 0x95d04aee3b80ece5U, 0xbb445da9ca61281fU,
847  0xea1575143cf97226U, 0x924d692ca61be758U, 0xb6e0c377cfa2e12eU,
848  0xe498f455c38b997aU, 0x8edf98b59a373fecU, 0xb2977ee300c50fe7U,
849  0xdf3d5e9bc0f653e1U, 0x8b865b215899f46cU, 0xae67f1e9aec07187U,
850  0xda01ee641a708de9U, 0x884134fe908658b2U, 0xaa51823e34a7eedeU,
851  0xd4e5e2cdc1d1ea96U, 0x850fadc09923329eU, 0xa6539930bf6bff45U,
852  0xcfe87f7cef46ff16U, 0x81f14fae158c5f6eU, 0xa26da3999aef7749U,
853  0xcb090c8001ab551cU, 0xfdcb4fa002162a63U, 0x9e9f11c4014dda7eU,
854  0xc646d63501a1511dU, 0xf7d88bc24209a565U, 0x9ae757596946075fU,
855  0xc1a12d2fc3978937U, 0xf209787bb47d6b84U, 0x9745eb4d50ce6332U,
856  0xbd176620a501fbffU, 0xec5d3fa8ce427affU, 0x93ba47c980e98cdfU,
857  0xb8a8d9bbe123f017U, 0xe6d3102ad96cec1dU, 0x9043ea1ac7e41392U,
858  0xb454e4a179dd1877U, 0xe16a1dc9d8545e94U, 0x8ce2529e2734bb1dU,
859  0xb01ae745b101e9e4U, 0xdc21a1171d42645dU, 0x899504ae72497ebaU,
860  0xabfa45da0edbde69U, 0xd6f8d7509292d603U, 0x865b86925b9bc5c2U,
861  0xa7f26836f282b732U, 0xd1ef0244af2364ffU, 0x8335616aed761f1fU,
862  0xa402b9c5a8d3a6e7U, 0xcd036837130890a1U, 0x802221226be55a64U,
863  0xa02aa96b06deb0fdU, 0xc83553c5c8965d3dU, 0xfa42a8b73abbf48cU,
864  0x9c69a97284b578d7U, 0xc38413cf25e2d70dU, 0xf46518c2ef5b8cd1U,
865  0x98bf2f79d5993802U, 0xbeeefb584aff8603U, 0xeeaaba2e5dbf6784U,
866  0x952ab45cfa97a0b2U, 0xba756174393d88dfU, 0xe912b9d1478ceb17U,
867  0x91abb422ccb812eeU, 0xb616a12b7fe617aaU, 0xe39c49765fdf9d94U,
868  0x8e41ade9fbebc27dU, 0xb1d219647ae6b31cU, 0xde469fbd99a05fe3U,
869  0x8aec23d680043beeU, 0xada72ccc20054ae9U, 0xd910f7ff28069da4U,
870  0x87aa9aff79042286U, 0xa99541bf57452b28U, 0xd3fa922f2d1675f2U,
871  0x847c9b5d7c2e09b7U, 0xa59bc234db398c25U, 0xcf02b2c21207ef2eU,
872  0x8161afb94b44f57dU, 0xa1ba1ba79e1632dcU, 0xca28a291859bbf93U,
873  0xfcb2cb35e702af78U, 0x9defbf01b061adabU, 0xc56baec21c7a1916U,
874  0xf6c69a72a3989f5bU, 0x9a3c2087a63f6399U, 0xc0cb28a98fcf3c7fU,
875  0xf0fdf2d3f3c30b9fU, 0x969eb7c47859e743U, 0xbc4665b596706114U,
876  0xeb57ff22fc0c7959U, 0x9316ff75dd87cbd8U, 0xb7dcbf5354e9beceU,
877  0xe5d3ef282a242e81U, 0x8fa475791a569d10U, 0xb38d92d760ec4455U,
878  0xe070f78d3927556aU, 0x8c469ab843b89562U, 0xaf58416654a6babbU,
879  0xdb2e51bfe9d0696aU, 0x88fcf317f22241e2U, 0xab3c2fddeeaad25aU,
880  0xd60b3bd56a5586f1U, 0x85c7056562757456U, 0xa738c6bebb12d16cU,
881  0xd106f86e69d785c7U, 0x82a45b450226b39cU, 0xa34d721642b06084U,
882  0xcc20ce9bd35c78a5U, 0xff290242c83396ceU, 0x9f79a169bd203e41U,
883  0xc75809c42c684dd1U, 0xf92e0c3537826145U, 0x9bbcc7a142b17ccbU,
884  0xc2abf989935ddbfeU, 0xf356f7ebf83552feU, 0x98165af37b2153deU,
885  0xbe1bf1b059e9a8d6U, 0xeda2ee1c7064130cU, 0x9485d4d1c63e8be7U,
886  0xb9a74a0637ce2ee1U, 0xe8111c87c5c1ba99U, 0x910ab1d4db9914a0U,
887  0xb54d5e4a127f59c8U, 0xe2a0b5dc971f303aU, 0x8da471a9de737e24U,
888  0xb10d8e1456105dadU, 0xdd50f1996b947518U, 0x8a5296ffe33cc92fU,
889  0xace73cbfdc0bfb7bU, 0xd8210befd30efa5aU, 0x8714a775e3e95c78U,
890  0xa8d9d1535ce3b396U, 0xd31045a8341ca07cU, 0x83ea2b892091e44dU,
891  0xa4e4b66b68b65d60U, 0xce1de40642e3f4b9U, 0x80d2ae83e9ce78f3U,
892  0xa1075a24e4421730U, 0xc94930ae1d529cfcU, 0xfb9b7cd9a4a7443cU,
893  0x9d412e0806e88aa5U, 0xc491798a08a2ad4eU, 0xf5b5d7ec8acb58a2U,
894  0x9991a6f3d6bf1765U, 0xbff610b0cc6edd3fU, 0xeff394dcff8a948eU,
895  0x95f83d0a1fb69cd9U, 0xbb764c4ca7a4440fU, 0xea53df5fd18d5513U,
896  0x92746b9be2f8552cU, 0xb7118682dbb66a77U, 0xe4d5e82392a40515U,
897  0x8f05b1163ba6832dU, 0xb2c71d5bca9023f8U, 0xdf78e4b2bd342cf6U,
898  0x8bab8eefb6409c1aU, 0xae9672aba3d0c320U, 0xda3c0f568cc4f3e8U,
899  0x8865899617fb1871U, 0xaa7eebfb9df9de8dU, 0xd51ea6fa85785631U,
900  0x8533285c936b35deU, 0xa67ff273b8460356U, 0xd01fef10a657842cU,
901  0x8213f56a67f6b29bU, 0xa298f2c501f45f42U, 0xcb3f2f7642717713U,
902  0xfe0efb53d30dd4d7U, 0x9ec95d1463e8a506U, 0xc67bb4597ce2ce48U,
903  0xf81aa16fdc1b81daU, 0x9b10a4e5e9913128U, 0xc1d4ce1f63f57d72U,
904  0xf24a01a73cf2dccfU, 0x976e41088617ca01U, 0xbd49d14aa79dbc82U,
905  0xec9c459d51852ba2U, 0x93e1ab8252f33b45U, 0xb8da1662e7b00a17U,
906  0xe7109bfba19c0c9dU, 0x906a617d450187e2U, 0xb484f9dc9641e9daU,
907  0xe1a63853bbd26451U, 0x8d07e33455637eb2U, 0xb049dc016abc5e5fU,
908  0xdc5c5301c56b75f7U, 0x89b9b3e11b6329baU, 0xac2820d9623bf429U,
909  0xd732290fbacaf133U, 0x867f59a9d4bed6c0U, 0xa81f301449ee8c70U,
910  0xd226fc195c6a2f8cU, 0x83585d8fd9c25db7U, 0xa42e74f3d032f525U,
911  0xcd3a1230c43fb26fU, 0x80444b5e7aa7cf85U, 0xa0555e361951c366U,
912  0xc86ab5c39fa63440U, 0xfa856334878fc150U, 0x9c935e00d4b9d8d2U,
913  0xc3b8358109e84f07U, 0xf4a642e14c6262c8U, 0x98e7e9cccfbd7dbdU,
914  0xbf21e44003acdd2cU, 0xeeea5d5004981478U, 0x95527a5202df0ccbU,
915  0xbaa718e68396cffdU, 0xe950df20247c83fdU, 0x91d28b7416cdd27eU,
916  0xb6472e511c81471dU, 0xe3d8f9e563a198e5U, 0x8e679c2f5e44ff8fU,
917 };
918 
919 const int16_t kPower10ExponentTable[] = {
920  -1200, -1196, -1193, -1190, -1186, -1183, -1180, -1176, -1173, -1170, -1166,
921  -1163, -1160, -1156, -1153, -1150, -1146, -1143, -1140, -1136, -1133, -1130,
922  -1127, -1123, -1120, -1117, -1113, -1110, -1107, -1103, -1100, -1097, -1093,
923  -1090, -1087, -1083, -1080, -1077, -1073, -1070, -1067, -1063, -1060, -1057,
924  -1053, -1050, -1047, -1043, -1040, -1037, -1034, -1030, -1027, -1024, -1020,
925  -1017, -1014, -1010, -1007, -1004, -1000, -997, -994, -990, -987, -984,
926  -980, -977, -974, -970, -967, -964, -960, -957, -954, -950, -947,
927  -944, -940, -937, -934, -931, -927, -924, -921, -917, -914, -911,
928  -907, -904, -901, -897, -894, -891, -887, -884, -881, -877, -874,
929  -871, -867, -864, -861, -857, -854, -851, -847, -844, -841, -838,
930  -834, -831, -828, -824, -821, -818, -814, -811, -808, -804, -801,
931  -798, -794, -791, -788, -784, -781, -778, -774, -771, -768, -764,
932  -761, -758, -754, -751, -748, -744, -741, -738, -735, -731, -728,
933  -725, -721, -718, -715, -711, -708, -705, -701, -698, -695, -691,
934  -688, -685, -681, -678, -675, -671, -668, -665, -661, -658, -655,
935  -651, -648, -645, -642, -638, -635, -632, -628, -625, -622, -618,
936  -615, -612, -608, -605, -602, -598, -595, -592, -588, -585, -582,
937  -578, -575, -572, -568, -565, -562, -558, -555, -552, -549, -545,
938  -542, -539, -535, -532, -529, -525, -522, -519, -515, -512, -509,
939  -505, -502, -499, -495, -492, -489, -485, -482, -479, -475, -472,
940  -469, -465, -462, -459, -455, -452, -449, -446, -442, -439, -436,
941  -432, -429, -426, -422, -419, -416, -412, -409, -406, -402, -399,
942  -396, -392, -389, -386, -382, -379, -376, -372, -369, -366, -362,
943  -359, -356, -353, -349, -346, -343, -339, -336, -333, -329, -326,
944  -323, -319, -316, -313, -309, -306, -303, -299, -296, -293, -289,
945  -286, -283, -279, -276, -273, -269, -266, -263, -259, -256, -253,
946  -250, -246, -243, -240, -236, -233, -230, -226, -223, -220, -216,
947  -213, -210, -206, -203, -200, -196, -193, -190, -186, -183, -180,
948  -176, -173, -170, -166, -163, -160, -157, -153, -150, -147, -143,
949  -140, -137, -133, -130, -127, -123, -120, -117, -113, -110, -107,
950  -103, -100, -97, -93, -90, -87, -83, -80, -77, -73, -70,
951  -67, -63, -60, -57, -54, -50, -47, -44, -40, -37, -34,
952  -30, -27, -24, -20, -17, -14, -10, -7, -4, 0, 3,
953  6, 10, 13, 16, 20, 23, 26, 30, 33, 36, 39,
954  43, 46, 49, 53, 56, 59, 63, 66, 69, 73, 76,
955  79, 83, 86, 89, 93, 96, 99, 103, 106, 109, 113,
956  116, 119, 123, 126, 129, 132, 136, 139, 142, 146, 149,
957  152, 156, 159, 162, 166, 169, 172, 176, 179, 182, 186,
958  189, 192, 196, 199, 202, 206, 209, 212, 216, 219, 222,
959  226, 229, 232, 235, 239, 242, 245, 249, 252, 255, 259,
960  262, 265, 269, 272, 275, 279, 282, 285, 289, 292, 295,
961  299, 302, 305, 309, 312, 315, 319, 322, 325, 328, 332,
962  335, 338, 342, 345, 348, 352, 355, 358, 362, 365, 368,
963  372, 375, 378, 382, 385, 388, 392, 395, 398, 402, 405,
964  408, 412, 415, 418, 422, 425, 428, 431, 435, 438, 441,
965  445, 448, 451, 455, 458, 461, 465, 468, 471, 475, 478,
966  481, 485, 488, 491, 495, 498, 501, 505, 508, 511, 515,
967  518, 521, 524, 528, 531, 534, 538, 541, 544, 548, 551,
968  554, 558, 561, 564, 568, 571, 574, 578, 581, 584, 588,
969  591, 594, 598, 601, 604, 608, 611, 614, 617, 621, 624,
970  627, 631, 634, 637, 641, 644, 647, 651, 654, 657, 661,
971  664, 667, 671, 674, 677, 681, 684, 687, 691, 694, 697,
972  701, 704, 707, 711, 714, 717, 720, 724, 727, 730, 734,
973  737, 740, 744, 747, 750, 754, 757, 760, 764, 767, 770,
974  774, 777, 780, 784, 787, 790, 794, 797, 800, 804, 807,
975  810, 813, 817, 820, 823, 827, 830, 833, 837, 840, 843,
976  847, 850, 853, 857, 860, 863, 867, 870, 873, 877, 880,
977  883, 887, 890, 893, 897, 900, 903, 907, 910, 913, 916,
978  920, 923, 926, 930, 933, 936, 940, 943, 946, 950, 953,
979  956, 960,
980 };
981 
982 } // namespace
983 } // namespace absl
constexpr uint64_t Uint128High64(uint128 v)
Definition: int128.h:389
uint64_t mantissa
Definition: charconv.cc:238
Dest bit_cast(const Source &source)
Definition: casts.h:154
ABSL_BASE_INTERNAL_FORCEINLINE int CountLeadingZeros64(uint64_t n)
Definition: bits.h:60
constexpr uint64_t Uint128Low64(uint128 v)
Definition: int128.h:387
template ParsedFloat ParseFloat< 10 >(const char *begin, const char *end, chars_format format_flags)
std::pair< uint64_t, uint64_t > uint128
Definition: city.h:55
Definition: algorithm.h:29
const char * ptr
Definition: charconv.h:44
template ParsedFloat ParseFloat< 16 >(const char *begin, const char *end, chars_format format_flags)
size_t value
int exponent
Definition: charconv.cc:239
from_chars_result from_chars(const char *first, const char *last, double &value, chars_format fmt)
Definition: charconv.cc:679
static BigUnsigned FiveToTheNth(int n)
int Compare(const BigUnsigned< N > &lhs, const BigUnsigned< M > &rhs)
int ReadFloatMantissa(const ParsedFloat &fp, int significant_digits)
chars_format
Definition: charconv.h:26


abseil_cpp
Author(s):
autogenerated on Tue Jun 18 2019 19:44:35