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"
23#include "absl/base/internal/bits.h"
24#include "absl/numeric/int128.h"
25#include "absl/strings/internal/charconv_bigint.h"
26#include "absl/strings/internal/charconv_parse.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
59namespace absl {
60namespace {
61
62template <typename FloatType>
63struct FloatTraits;
64
65template <>
66struct 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.
134template <>
135struct 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].
188extern const uint64_t kPower10MantissaTable[];
189extern 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.)
194constexpr 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.)
199constexpr int kPower10TableMax = 308;
200
201uint64_t Power10Mantissa(int n) {
202 return kPower10MantissaTable[n - kPower10TableMin];
203}
204
205int 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.
211bool 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.
215bool 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).
220bool 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.
224constexpr int kOverflow = 99999;
225constexpr 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.
237struct 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.)
244int BitWidth(uint128 value) {
245 if (Uint128High64(value) == 0) {
246 return 64 - base_internal::CountLeadingZeros64(Uint128Low64(value));
247 }
248 return 128 - base_internal::CountLeadingZeros64(Uint128High64(value));
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.
259template <typename FloatType>
260int 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.
273int 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.
283template <typename FloatType>
284bool 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.
326template <typename FloatType>
327void 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.
371uint64_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.
428bool 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.)
434 absl::strings_internal::BigUnsigned<84> exact_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
465 absl::strings_internal::BigUnsigned<84> rhs =
466 absl::strings_internal::BigUnsigned<84>::FiveToTheNth(-exact_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.
498template <typename FloatType>
499CalculatedFloat 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
516template <typename FloatType>
517CalculatedFloat 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
532template <typename FloatType>
533CalculatedFloat 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
597template <typename FloatType>
598from_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
679from_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
684from_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
689namespace {
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
699const 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
919const 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
984