* [PATCH 1/6 v2] libstdc++: Directly implement hexfloat std::from_chars for binary32/64
@ 2022-01-16 18:06 Patrick Palka
2022-01-16 18:06 ` [PATCH 2/6] libstdc++: Import the fast_float library Patrick Palka
` (5 more replies)
0 siblings, 6 replies; 15+ messages in thread
From: Patrick Palka @ 2022-01-16 18:06 UTC (permalink / raw)
To: gcc-patches; +Cc: libstdc++, Patrick Palka
Series tested on x86_64, i686, ppc64, ppc64le, aarch64, does it look OK for
trunk?
libstdc++-v3/ChangeLog:
* src/c++17/floating_from_chars.cc: Include <bit>.
(ascii_to_hexit, starts_with_ci): Define.
(__floating_from_chars_hex): Define.
(from_chars): Conditionally call __floating_from_chars_hex.
(testsuite/20_util/from_chars/7.cc): New test.
---
libstdc++-v3/src/c++17/floating_from_chars.cc | 376 ++++++++++++++++++
.../testsuite/20_util/from_chars/7.cc | 151 +++++++
2 files changed, 527 insertions(+)
create mode 100644 libstdc++-v3/testsuite/20_util/from_chars/7.cc
diff --git a/libstdc++-v3/src/c++17/floating_from_chars.cc b/libstdc++-v3/src/c++17/floating_from_chars.cc
index 479e042bb5f..b186da9a955 100644
--- a/libstdc++-v3/src/c++17/floating_from_chars.cc
+++ b/libstdc++-v3/src/c++17/floating_from_chars.cc
@@ -31,6 +31,7 @@
#define _GLIBCXX_USE_CXX11_ABI 1
#include <charconv>
+#include <bit>
#include <string>
#include <memory_resource>
#include <cfenv>
@@ -396,6 +397,371 @@ namespace
}
#endif
+#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64
+ // If the given ASCII character represents a hexit, return that hexit.
+ // Otherwise return -1.
+ int
+ ascii_to_hexit(char ch)
+ {
+ if (ch >= '0' && ch <= '9')
+ return ch - '0';
+ if (ch >= 'a' && ch <= 'f')
+ return ch - 'a' + 10;
+ if (ch >= 'A' && ch <= 'F')
+ return ch - 'A' + 10;
+ return -1;
+ }
+
+ // Return true iff [FIRST,LAST) begins with PREFIX, ignoring case.
+ bool
+ starts_with_ci(const char* first, const char* last, string_view prefix)
+ {
+ __glibcxx_requires_valid_range(first, last);
+
+ for (char ch : prefix)
+ {
+ __glibcxx_assert(ch >= 'a' && ch <= 'z');
+ if (first == last || (*first != ch && *first != ch - 32))
+ return false;
+ ++first;
+ }
+
+ return true;
+ }
+
+ // An implementation of hexadecimal float parsing for binary32/64.
+ template<typename T>
+ from_chars_result
+ __floating_from_chars_hex(const char* first, const char* last, T& value)
+ {
+ static_assert(is_same_v<T, float> || is_same_v<T, double>);
+
+ using uint_t = conditional_t<is_same_v<T, float>, uint32_t, uint64_t>;
+ constexpr int mantissa_width = is_same_v<T, float> ? 23 : 52;
+ constexpr int exponent_width = is_same_v<T, float> ? 8 : 11;
+ constexpr int exponent_bias = (1 << (exponent_width - 1)) - 1;
+
+ __glibcxx_requires_valid_range(first, last);
+ if (first == last)
+ return {first, errc::invalid_argument};
+
+ // Consume the sign bit.
+ const char* const orig_first = first;
+ bool sign_bit = false;
+ if (*first == '-')
+ {
+ sign_bit = true;
+ ++first;
+ }
+
+ // Handle "inf", "infinity", "NaN" and variants thereof.
+ if (first != last)
+ if (*first == 'i' || *first == 'I' || *first == 'n' || *first == 'N') [[unlikely]]
+ {
+ if (starts_with_ci(first, last, "inf"sv))
+ {
+ first += 3;
+ if (starts_with_ci(first, last, "inity"sv))
+ first += 5;
+
+ uint_t result = 0;
+ result |= sign_bit;
+ result <<= exponent_width;
+ result |= (1ull << exponent_width) - 1;
+ result <<= mantissa_width;
+ memcpy(&value, &result, sizeof(result));
+
+ return {first, errc{}};
+ }
+ else if (starts_with_ci(first, last, "nan"))
+ {
+ first += 3;
+
+ if (first != last && *first == '(')
+ {
+ // Tentatively consume the '(' as we look for an optional
+ // n-char-sequence followed by a ')'.
+ const char* const fallback_first = first;
+ for (;;)
+ {
+ ++first;
+ if (first == last)
+ {
+ first = fallback_first;
+ break;
+ }
+
+ char ch = *first;
+ if (ch == ')')
+ {
+ ++first;
+ break;
+ }
+ else if ((ch >= '0' && ch <= '9')
+ || (ch >= 'a' && ch <= 'z')
+ || (ch >= 'A' && ch <= 'Z')
+ || ch == '_')
+ continue;
+ else
+ {
+ first = fallback_first;
+ break;
+ }
+ }
+ }
+
+ // We make the implementation-defined decision of ignoring the
+ // sign bit and the n-char-sequence when assembling the NaN.
+ uint_t result = 0;
+ result <<= exponent_width;
+ result |= (1ull << exponent_width) - 1;
+ result <<= mantissa_width;
+ result |= (1ull << (mantissa_width - 1)) | 1;
+ memcpy(&value, &result, sizeof(result));
+
+ return {first, errc{}};
+ }
+ }
+
+ // Consume all insignificant leading zeros in the whole part of the
+ // mantissa.
+ bool seen_digit = false;
+ while (first != last && *first == '0')
+ {
+ seen_digit = true;
+ ++first;
+ }
+
+ // Now consume the rest of the written mantissa, populating MANTISSA with the
+ // first MANTISSA_WIDTH+k significant bits of the written mantissa, where 1
+ // <= k <= 4 is the bit width of the leading significant written hexit.
+ //
+ // Examples:
+ // After parsing "1.2f3", MANTISSA is 0x12f30000000000 (bit_width=52+1).
+ // After parsing ".0000f0e", MANTISSA is 0xf0e00000000000 (bit_width=52+4).
+ // After parsing ".1234567890abcd8", MANTISSA is 0x1234567890abcd (bit_width=52+1)
+ // and MIDPOINT_BIT is true and NONZERO_TAIL is false.
+ uint_t mantissa = 0;
+ int mantissa_idx = mantissa_width; // The current bit index into MANTISSA
+ // into which we'll write the next hexit.
+ int exponent_adjustment = 0; // How much we'd have to adjust the written
+ // exponent in order to represent the mantissa
+ // in scientific form h.hhhhhhhhhhhhh.
+ bool midpoint_bit = false; // Whether the MANTISSA_WIDTH+k+1 significant
+ // bit is set in the written mantissa.
+ bool nonzero_tail = false; // Whether some bit thereafter is set in the
+ // written mantissa.
+ bool seen_decimal_point = false;
+ for (; first != last; ++first)
+ {
+ char ch = *first;
+ if (ch == '.' && !seen_decimal_point)
+ {
+ seen_decimal_point = true;
+ continue;
+ }
+
+ int hexit = ascii_to_hexit(ch);
+ if (hexit == -1)
+ break;
+ seen_digit = true;
+
+ if (!seen_decimal_point && mantissa != 0)
+ exponent_adjustment += 4;
+ else if (seen_decimal_point && mantissa == 0)
+ {
+ exponent_adjustment -= 4;
+ if (hexit == 0x0)
+ continue;
+ }
+
+ if (mantissa_idx >= 0)
+ mantissa |= uint_t(hexit) << mantissa_idx;
+ else if (mantissa_idx >= -4)
+ {
+ if constexpr (is_same_v<T, float>)
+ {
+ __glibcxx_assert(mantissa_idx == -1);
+ mantissa |= hexit >> 1;
+ midpoint_bit = (hexit & 0b0001) != 0;
+ }
+ else
+ {
+ __glibcxx_assert(mantissa_idx == -4);
+ midpoint_bit = (hexit & 0b1000) != 0;
+ nonzero_tail = (hexit & 0b0111) != 0;
+ }
+ }
+ else
+ nonzero_tail |= (hexit != 0x0);
+
+ mantissa_idx -= 4;
+ }
+ if (mantissa != 0)
+ __glibcxx_assert(__bit_width(mantissa) >= mantissa_width + 1
+ && __bit_width(mantissa) <= mantissa_width + 4);
+ else
+ __glibcxx_assert(!midpoint_bit && !nonzero_tail);
+
+ if (!seen_digit)
+ {
+ // If we haven't seen any digit at this point, the parse failed.
+ first = orig_first;
+ return {first, errc::invalid_argument};
+ }
+
+ // Parse the written exponent.
+ int written_exponent = 0;
+ if (first != last && *first == 'p')
+ {
+ // Tentatively consume the the 'p' and try to parse a decimal number.
+ const char* const fallback_first = first;
+ ++first;
+ if (first != last && *first == '+')
+ ++first;
+ from_chars_result fcr = from_chars(first, last, written_exponent, 10);
+ if (fcr.ptr == first)
+ // The parse failed, so undo consuming the 'p' and carry on as if the
+ // exponent was omitted (i.e. is 0).
+ first = fallback_first;
+ else
+ {
+ first = fcr.ptr;
+ if (mantissa != 0 && fcr.ec == errc::result_out_of_range)
+ // FIXME: Punt on large exponents for now.
+ return {first, errc::result_out_of_range};
+ }
+ }
+ int biased_exponent = written_exponent + exponent_bias;
+ if (exponent_adjustment != 0)
+ // The mantissa wasn't written in scientific form. Adjust the exponent
+ // so that we may assume scientific form.
+ //
+ // Examples;
+ // For input "a.bcp5", EXPONENT_ADJUSTMENT would be 0 since this
+ // written mantissa is already in scientific form.
+ // For input "ab.cp5", EXPONENT_ADJUSTMENT would be 4 since the
+ // scientific form is "a.bcp9".
+ // For input 0.0abcp5", EXPONENT_ADJUSTMENT would be -8 since the
+ // scientific form is "a.bcp-3".
+ biased_exponent += exponent_adjustment;
+
+ // Shifts the mantissa to the right by AMOUNT while updating
+ // BIASED_EXPONENT, MIDPOINT_BIT and NONZERO_TAIL accordingly.
+ auto shift_mantissa = [&] (int amount) {
+ __glibcxx_assert(amount >= 0);
+ if (amount > mantissa_width + 1)
+ {
+ // Shifting the mantissa by an amount greater than its precision.
+ nonzero_tail |= midpoint_bit;
+ nonzero_tail |= mantissa != 0;
+ midpoint_bit = false;
+ mantissa = 0;
+ biased_exponent += amount;
+ }
+ else if (amount != 0)
+ {
+ nonzero_tail |= midpoint_bit;
+ nonzero_tail |= (mantissa & ((1ull << (amount - 1)) - 1)) != 0;
+ midpoint_bit = (mantissa & (1ull << (amount - 1))) != 0;
+ mantissa >>= amount;
+ biased_exponent += amount;
+ }
+ };
+
+ if (mantissa != 0)
+ {
+ // If the leading hexit is not '1', shift MANTISSA to make it so.
+ // This normalizes input like "4.04p0" into "1.01p2".
+ const int leading_hexit = mantissa >> mantissa_width;
+ const int leading_hexit_width = __bit_width(leading_hexit); // FIXME: optimize?
+ __glibcxx_assert(leading_hexit_width >= 1 && leading_hexit_width <= 4);
+ shift_mantissa(leading_hexit_width - 1);
+ // After this adjustment, we can assume the leading hexit is a '1'.
+ __glibcxx_assert((mantissa >> mantissa_width) == 0x1);
+ }
+
+ if (biased_exponent <= 0)
+ {
+ // This number is too small to be represented as a normal number, so
+ // try for a subnormal number by shifting the mantissa sufficiently.
+ // We need to shift by 1 more than -BIASED_EXPONENT because the leading
+ // mantissa bit is omitted in the representation of a normal number but
+ // not in a subnormal number.
+ shift_mantissa(-biased_exponent + 1);
+ __glibcxx_assert(!(mantissa & (1ull << mantissa_width)));
+ __glibcxx_assert(biased_exponent == 1);
+ biased_exponent = 0;
+ }
+
+ // Perform round-to-nearest, tie-to-even rounding.
+ if (midpoint_bit && (nonzero_tail || (mantissa % 2) != 0))
+ {
+ // Rounding away from zero.
+ ++mantissa;
+ midpoint_bit = false;
+ nonzero_tail = false;
+
+ // Deal with a couple of corner cases after rounding.
+ if (mantissa == (1ull << mantissa_width))
+ {
+ // We rounded the subnormal number 1.fffffffffffff...p-1023
+ // up to the normal number 1p-1022.
+ __glibcxx_assert(biased_exponent == 0);
+ ++biased_exponent;
+ }
+ else if (mantissa & (1ull << (mantissa_width + 1)))
+ {
+ // We rounded the normal number 1.fffffffffffff8pN (with maximal
+ // mantissa) up to to 1p(N+1).
+ mantissa >>= 1;
+ ++biased_exponent;
+ }
+ }
+ else
+ {
+ // Rounding towards zero.
+
+ if (mantissa == 0 && (midpoint_bit || nonzero_tail))
+ {
+ // A nonzero number that rounds to zero is unrepresentable.
+ __glibcxx_assert(biased_exponent == 0);
+ return {first, errc::result_out_of_range};
+ }
+
+ midpoint_bit = false;
+ nonzero_tail = false;
+ }
+
+ if (mantissa != 0 && biased_exponent >= (1 << exponent_width) - 1)
+ // The exponent of this number is too large to be representable.
+ return {first, errc::result_out_of_range};
+
+ uint_t result = 0;
+ if (mantissa == 0)
+ {
+ // Assemble a (possibly signed) zero.
+ if (sign_bit)
+ result |= 1ull << (exponent_width + mantissa_width);
+ }
+ else
+ {
+ // Assemble a nonzero normal or subnormal value.
+ result |= sign_bit;
+ result <<= exponent_width;
+ result |= biased_exponent;
+ result <<= mantissa_width;
+ result |= mantissa & ((1ull << mantissa_width) - 1);
+ // The implicit leading mantissa bit is set iff the number is normal.
+ __glibcxx_assert(((mantissa & (1ull << mantissa_width)) != 0)
+ == (biased_exponent != 0));
+ }
+ memcpy(&value, &result, sizeof(result));
+
+ return {first, errc{}};
+ }
+#endif
+
} // namespace
// FIXME: This should be reimplemented so it doesn't use strtod and newlocale.
@@ -406,6 +772,11 @@ from_chars_result
from_chars(const char* first, const char* last, float& value,
chars_format fmt) noexcept
{
+#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64
+ if (fmt == chars_format::hex)
+ return __floating_from_chars_hex(first, last, value);
+#endif
+
errc ec = errc::invalid_argument;
#if _GLIBCXX_USE_CXX11_ABI
buffer_resource mr;
@@ -432,6 +803,11 @@ from_chars_result
from_chars(const char* first, const char* last, double& value,
chars_format fmt) noexcept
{
+#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64
+ if (fmt == chars_format::hex)
+ return __floating_from_chars_hex(first, last, value);
+#endif
+
errc ec = errc::invalid_argument;
#if _GLIBCXX_USE_CXX11_ABI
buffer_resource mr;
diff --git a/libstdc++-v3/testsuite/20_util/from_chars/7.cc b/libstdc++-v3/testsuite/20_util/from_chars/7.cc
new file mode 100644
index 00000000000..090ad7a87bb
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/from_chars/7.cc
@@ -0,0 +1,151 @@
+// Various testcases for binary64 hexfloat std::from_chars.
+// { dg-do run { target c++17 } }
+// { dg-require-effective-target ieee_floats }
+
+#include <charconv>
+
+#include <cfenv>
+#include <cmath>
+#include <cstring>
+#include <cstdio>
+#include <limits>
+#include <testsuite_hooks.h>
+
+struct testcase {
+ const char* input;
+ size_t correct_idx;
+ std::errc correct_ec;
+ double correct_value;
+};
+
+constexpr testcase testcases[] = {
+ { "1.fffffffffffff8p0", 18, {}, 0x1.fffffffffffff8p0 },
+ { "0.fffffffffffff8p-1022", 22, std::errc{}, 0x0.fffffffffffffep-1022 },
+ { "inf", 3, {}, std::numeric_limits<double>::infinity() },
+ { "inff", 3, {}, std::numeric_limits<double>::infinity() },
+ { "-inf", 4, {}, -std::numeric_limits<double>::infinity() },
+ { "-inff", 4, {}, -std::numeric_limits<double>::infinity() },
+ { "NAN", 3, {}, std::numeric_limits<double>::quiet_NaN() },
+ { "-NAN", 4, {}, std::numeric_limits<double>::quiet_NaN() },
+ { "NAN()", 5, {}, std::numeric_limits<double>::quiet_NaN() },
+ { "-NAN()", 6, {}, std::numeric_limits<double>::quiet_NaN() },
+ { "-NAN(test)", 10, {}, std::numeric_limits<double>::quiet_NaN() },
+ { "-NAN(test", 4, {}, std::numeric_limits<double>::quiet_NaN() },
+ { "-NAN(", 4, {}, std::numeric_limits<double>::quiet_NaN() },
+ { "0.000000000000001p-100000000000000000", 37, std::errc::result_out_of_range, 0 },
+ { "-lol", 0, std::errc::invalid_argument, 1 },
+ { " 0", 0, std::errc::invalid_argument, 1 },
+ { "", 0, std::errc::invalid_argument, 0 },
+ { "1", 1, {}, 1 },
+ { "2", 1, {}, 2 },
+ { "3", 1, {}, 3 },
+ { "4", 1, {}, 4 },
+ { "5", 1, {}, 5 },
+ { "6", 1, {}, 6 },
+ { "7", 1, {}, 7 },
+ { "8", 1, {}, 8 },
+ { "9", 1, {}, 9 },
+ { "a", 1, {}, 0xa },
+ { "b", 1, {}, 0xb },
+ { "c", 1, {}, 0xc },
+ { "d", 1, {}, 0xd },
+ { "e", 1, {}, 0xe },
+ { "f", 1, {}, 0xf },
+ { "0.000000000000000000000000000000000000000000001p-1022", 53,
+ std::errc::result_out_of_range, 0 },
+ { "0.00000000000000p-1022", 22, {}, 0 },
+ { "0.00000000000009", 16, {}, 0x0.00000000000009p0 },
+ { "0.0", 3, {}, 0 },
+ { "1p10000000000000000000000", 25, std::errc::result_out_of_range, 0 },
+ { "-0.0", 4, {}, -0.0 },
+ { "0.00000000000000", 16, {}, 0 },
+ { "0.0000000000000p-1022", 21, {}, 0 },
+ { ".", 0, std::errc::invalid_argument, 0 },
+ { "-.", 0, std::errc::invalid_argument, 0 },
+ { "0", 1, {}, 0 },
+ { "00", 2, {}, 0 },
+ { "00.", 3, {}, 0 },
+ { "0.", 2, {}, 0 },
+ { "1.ffffFFFFFFFFFF", 16, {}, 0x2 },
+ { "1.ffffffffffffff", 16, {}, 0x2 },
+ { "1.00000000000029", 16, {}, 0x1.0000000000003p0 },
+ { "0.00000000000008p-1022", 22, std::errc::result_out_of_range, 0 },
+ { "1.fffffffffffffp-1023", 21, {}, 0x1p-1022 },
+ { "1.fffffffffffff8p+1023", 22, std::errc::result_out_of_range, 0 },
+ { "0.ffffffffffffe8p-1022", 22, {}, 0x0.ffffffffffffep-1022 },
+ { "2.11111111111111", 16, {}, 0x1.0888888888889p+1 },
+ { "1.1111111111111", 15, {}, 0x1.1111111111111p0 },
+ { "1.11111111111111", 16, {}, 0x1.1111111111111p0 },
+ { "1.11111111111118", 16, {}, 0x1.1111111111112p0 },
+ { "1.11111111111128", 16, {}, 0x1.1111111111112p0 },
+ { "1.1111111111112801", 18, {}, 0x1.1111111111113p0 },
+ { "1.08888888888888", 16, {}, 0x1.0888888888888p0 },
+ { "1.088888888888888", 17, {}, 0x1.0888888888889p0 },
+ { "2.00000000000029", 16, {}, 0x2.0000000000002p0 },
+ { "0.ffffffffffffep-1022", 21, {}, 0x0.ffffffffffffep-1022 },
+ { "3.ffffffffffffep-1024", 21, {}, 0x1p-1022 },
+ { "1.00000000000008p+0", 19, {}, 1 },
+ { "1p-1023", 7, {}, 0x0.8p-1022 },
+ { "1p-1022", 7, {}, 0x1p-1022 },
+ { "1.1p-1033", 9, {}, 0x1.1p-1033 }, // 0.0022p-1022
+ { "22p-1038", 8, {}, 0x1.1p-1033 },
+ { "5", 1, {}, 0x5 },
+ { "a", 1, {}, 0xa },
+ { "1", 1, {}, 1.0 },
+ { "1p1", 3, {}, 0x1p1 },
+ { "1p-1", 4, {}, 0x1p-1 },
+ { "0", 1, {}, 0.0 },
+ { "A", 1, {}, 0xA },
+ { "-1", 2, {}, -1.0 },
+ { "-0", 2, {}, -0.0 },
+ { "42", 2, {}, 0x42p0 },
+ { "-42", 3, {}, -0x42p0 },
+ { ".1", 2, {}, 0x0.1p0 },
+ { "22p-1000", 8, {}, 0x22p-1000 },
+ { ".0000008", 8, {}, 0x.0000008p0 },
+ { ".0000008p-1022", 14, {}, 0x.0000008p-1022 },
+ { "1p-1074", 7, {}, 0x.0000000000001p-1022 },
+ { "9999999999999", 13, {}, 0x9999999999999p0 },
+ { "1.000000000000a000", 18, {}, 0x1.000000000000ap0 },
+ { "1.000000000000a001", 18, {}, 0x1.000000000000ap0 },
+ { "1.000000000000a800", 18, {}, 0x1.000000000000ap0 },
+ { "1.000000000000a801", 18, {}, 0x1.000000000000bp0 },
+ { "1.000000000000b800", 18, {}, 0x1.000000000000cp0 },
+ { "000000", 6, {}, 0x0 },
+ { "1p", 1, {}, 0x1 },
+ { "0p99999999999999999999", 22, {}, 0 },
+ { "1p99999999999999999999", 22, std::errc::result_out_of_range, 0 },
+ { "0p-99999999999999999999", 23, {}, 0 },
+ { "1p-99999999999999999999", 23, std::errc::result_out_of_range, 0 },
+ { "99999999999999999999999", 23, {}, 0x99999999999999999999999p0 },
+ { "-1.fffffffffffffp-1023", 22, {}, -0x1p-1022 },
+ { "1.337", 5, {}, 0x1.337p0 },
+};
+
+void
+test01()
+{
+ for (auto [input,correct_idx,correct_ec,correct_value] : testcases)
+ {
+ double value;
+ auto [ptr,ec] = std::from_chars(input, input+strlen(input),
+ value, std::chars_format::hex);
+ VERIFY( ptr == input + correct_idx );
+ VERIFY( ec == correct_ec );
+ if (ec == std::errc{})
+ {
+ if (std::isnan(value) && std::isnan(value))
+ ;
+ else
+ {
+ VERIFY( value == correct_value );
+ VERIFY( !memcmp(&value, &correct_value, sizeof(value)) );
+ }
+ }
+ }
+}
+
+int main()
+{
+ test01();
+}
--
2.35.0.rc1
^ permalink raw reply [flat|nested] 15+ messages in thread
* [PATCH 2/6] libstdc++: Import the fast_float library
2022-01-16 18:06 [PATCH 1/6 v2] libstdc++: Directly implement hexfloat std::from_chars for binary32/64 Patrick Palka
@ 2022-01-16 18:06 ` Patrick Palka
2022-01-17 10:45 ` Jonathan Wakely
2022-01-18 3:10 ` Hans-Peter Nilsson
2022-01-16 18:06 ` [PATCH 3/6] libstdc++: Apply modifications to our local copy of fast_float Patrick Palka
` (4 subsequent siblings)
5 siblings, 2 replies; 15+ messages in thread
From: Patrick Palka @ 2022-01-16 18:06 UTC (permalink / raw)
To: gcc-patches; +Cc: libstdc++, Patrick Palka
We're going to use the fast_float library in our (compiled-in)
floating-point std::from_chars implementation for faster and more
portable parsing of binary32/64 decimal strings.
The single file fast_float.h is an amalgamation of the entire library,
which can be (re)generated with the command
python3 ./script/amalgamate.py --license=MIT \
> $GCC_SRC/libstdc++-v3/c++17/fast_float/fast_float.h
[1]: https://github.com/fastfloat/fast_float
libstdc++-v3/ChangeLog:
* src/c++17/fast_float/LOCAL_PATCHES: New file.
* src/c++17/fast_float/MERGE: New file.
* src/c++17/fast_float/README.fd: New file, copied from the
fast_float library sources.
* src/c++17/fast_float/fast_float.h: New file, an amalgamation
of the fast_float library.
Signed-off-by: Patrick Palka <ppalka@redhat.com>
---
.../src/c++17/fast_float/LOCAL_PATCHES | 0
libstdc++-v3/src/c++17/fast_float/MERGE | 4 +
libstdc++-v3/src/c++17/fast_float/README.md | 218 ++
.../src/c++17/fast_float/fast_float.h | 2944 +++++++++++++++++
4 files changed, 3166 insertions(+)
create mode 100644 libstdc++-v3/src/c++17/fast_float/LOCAL_PATCHES
create mode 100644 libstdc++-v3/src/c++17/fast_float/MERGE
create mode 100644 libstdc++-v3/src/c++17/fast_float/README.md
create mode 100644 libstdc++-v3/src/c++17/fast_float/fast_float.h
diff --git a/libstdc++-v3/src/c++17/fast_float/LOCAL_PATCHES b/libstdc++-v3/src/c++17/fast_float/LOCAL_PATCHES
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/libstdc++-v3/src/c++17/fast_float/MERGE b/libstdc++-v3/src/c++17/fast_float/MERGE
new file mode 100644
index 00000000000..43bdc3981c8
--- /dev/null
+++ b/libstdc++-v3/src/c++17/fast_float/MERGE
@@ -0,0 +1,4 @@
+d35368cae610b4edeec61cd41e4d2367a4d33f58
+
+The first line of this file holds the git revision number of the
+last merge done from the master library sources.
diff --git a/libstdc++-v3/src/c++17/fast_float/README.md b/libstdc++-v3/src/c++17/fast_float/README.md
new file mode 100644
index 00000000000..1e1c06d0a3e
--- /dev/null
+++ b/libstdc++-v3/src/c++17/fast_float/README.md
@@ -0,0 +1,218 @@
+## fast_float number parsing library: 4x faster than strtod
+
+/badge.svg)
+/badge.svg)
+
+
+
+[](https://github.com/fastfloat/fast_float/actions/workflows/vs16-ci.yml)
+
+The fast_float library provides fast header-only implementations for the C++ from_chars
+functions for `float` and `double` types. These functions convert ASCII strings representing
+decimal values (e.g., `1.3e10`) into binary types. We provide exact rounding (including
+round to even). In our experience, these `fast_float` functions many times faster than comparable number-parsing functions from existing C++ standard libraries.
+
+Specifically, `fast_float` provides the following two functions with a C++17-like syntax (the library itself only requires C++11):
+
+```C++
+from_chars_result from_chars(const char* first, const char* last, float& value, ...);
+from_chars_result from_chars(const char* first, const char* last, double& value, ...);
+```
+
+The return type (`from_chars_result`) is defined as the struct:
+```C++
+struct from_chars_result {
+ const char* ptr;
+ std::errc ec;
+};
+```
+
+It parses the character sequence [first,last) for a number. It parses floating-point numbers expecting
+a locale-independent format equivalent to the C++17 from_chars function.
+The resulting floating-point value is the closest floating-point values (using either float or double),
+using the "round to even" convention for values that would otherwise fall right in-between two values.
+That is, we provide exact parsing according to the IEEE standard.
+
+
+Given a successful parse, the pointer (`ptr`) in the returned value is set to point right after the
+parsed number, and the `value` referenced is set to the parsed value. In case of error, the returned
+`ec` contains a representative error, otherwise the default (`std::errc()`) value is stored.
+
+The implementation does not throw and does not allocate memory (e.g., with `new` or `malloc`).
+
+It will parse infinity and nan values.
+
+Example:
+
+``` C++
+#include "fast_float/fast_float.h"
+#include <iostream>
+
+int main() {
+ const std::string input = "3.1416 xyz ";
+ double result;
+ auto answer = fast_float::from_chars(input.data(), input.data()+input.size(), result);
+ if(answer.ec != std::errc()) { std::cerr << "parsing failure\n"; return EXIT_FAILURE; }
+ std::cout << "parsed the number " << result << std::endl;
+ return EXIT_SUCCESS;
+}
+```
+
+
+Like the C++17 standard, the `fast_float::from_chars` functions take an optional last argument of
+the type `fast_float::chars_format`. It is a bitset value: we check whether
+`fmt & fast_float::chars_format::fixed` and `fmt & fast_float::chars_format::scientific` are set
+to determine whether we allow the fixed point and scientific notation respectively.
+The default is `fast_float::chars_format::general` which allows both `fixed` and `scientific`.
+
+The library seeks to follow the C++17 (see [20.19.3](http://eel.is/c++draft/charconv.from.chars).(7.1)) specification.
+* The `from_chars` function does not skip leading white-space characters.
+* [A leading `+` sign](https://en.cppreference.com/w/cpp/utility/from_chars) is forbidden.
+* It is generally impossible to represent a decimal value exactly as binary floating-point number (`float` and `double` types). We seek the nearest value. We round to an even mantissa when we are in-between two binary floating-point numbers.
+
+Furthermore, we have the following restrictions:
+* We only support `float` and `double` types at this time.
+* We only support the decimal format: we do not support hexadecimal strings.
+* For values that are either very large or very small (e.g., `1e9999`), we represent it using the infinity or negative infinity value.
+
+We support Visual Studio, macOS, Linux, freeBSD. We support big and little endian. We support 32-bit and 64-bit systems.
+
+
+
+## Using commas as decimal separator
+
+
+The C++ standard stipulate that `from_chars` has to be locale-independent. In
+particular, the decimal separator has to be the period (`.`). However,
+some users still want to use the `fast_float` library with in a locale-dependent
+manner. Using a separate function called `from_chars_advanced`, we allow the users
+to pass a `parse_options` instance which contains a custom decimal separator (e.g.,
+the comma). You may use it as follows.
+
+```C++
+#include "fast_float/fast_float.h"
+#include <iostream>
+
+int main() {
+ const std::string input = "3,1416 xyz ";
+ double result;
+ fast_float::parse_options options{fast_float::chars_format::general, ','};
+ auto answer = fast_float::from_chars_advanced(input.data(), input.data()+input.size(), result, options);
+ if((answer.ec != std::errc()) || ((result != 3.1416))) { std::cerr << "parsing failure\n"; return EXIT_FAILURE; }
+ std::cout << "parsed the number " << result << std::endl;
+ return EXIT_SUCCESS;
+}
+```
+
+
+## Reference
+
+- Daniel Lemire, [Number Parsing at a Gigabyte per Second](https://arxiv.org/abs/2101.11408), Software: Pratice and Experience 51 (8), 2021.
+
+## Other programming languages
+
+- [There is an R binding](https://github.com/eddelbuettel/rcppfastfloat) called `rcppfastfloat`.
+- [There is a Rust port of the fast_float library](https://github.com/aldanor/fast-float-rust/) called `fast-float-rust`.
+- [There is a Java port of the fast_float library](https://github.com/wrandelshofer/FastDoubleParser) called `FastDoubleParser`.
+- [There is a C# port of the fast_float library](https://github.com/CarlVerret/csFastFloat) called `csFastFloat`.
+
+
+## Relation With Other Work
+
+The fastfloat algorithm is part of the [LLVM standard libraries](https://github.com/llvm/llvm-project/commit/87c016078ad72c46505461e4ff8bfa04819fe7ba).
+
+The fast_float library provides a performance similar to that of the [fast_double_parser](https://github.com/lemire/fast_double_parser) library but using an updated algorithm reworked from the ground up, and while offering an API more in line with the expectations of C++ programmers. The fast_double_parser library is part of the [Microsoft LightGBM machine-learning framework](https://github.com/microsoft/LightGBM).
+
+## Users
+
+The fast_float library is used by [Apache Arrow](https://github.com/apache/arrow/pull/8494) where it multiplied the number parsing speed by two or three times. It is also used by [Yandex ClickHouse](https://github.com/ClickHouse/ClickHouse) and by [Google Jsonnet](https://github.com/google/jsonnet).
+
+
+## How fast is it?
+
+It can parse random floating-point numbers at a speed of 1 GB/s on some systems. We find that it is often twice as fast as the best available competitor, and many times faster than many standard-library implementations.
+
+<img src="http://lemire.me/blog/wp-content/uploads/2020/11/fastfloat_speed.png" width="400">
+
+```
+$ ./build/benchmarks/benchmark
+# parsing random integers in the range [0,1)
+volume = 2.09808 MB
+netlib : 271.18 MB/s (+/- 1.2 %) 12.93 Mfloat/s
+doubleconversion : 225.35 MB/s (+/- 1.2 %) 10.74 Mfloat/s
+strtod : 190.94 MB/s (+/- 1.6 %) 9.10 Mfloat/s
+abseil : 430.45 MB/s (+/- 2.2 %) 20.52 Mfloat/s
+fastfloat : 1042.38 MB/s (+/- 9.9 %) 49.68 Mfloat/s
+```
+
+See https://github.com/lemire/simple_fastfloat_benchmark for our benchmarking code.
+
+
+## Video
+
+[](http://www.youtube.com/watch?v=AVXgvlMeIm4)<br />
+
+## Using as a CMake dependency
+
+This library is header-only by design. The CMake file provides the `fast_float` target
+which is merely a pointer to the `include` directory.
+
+If you drop the `fast_float` repository in your CMake project, you should be able to use
+it in this manner:
+
+```cmake
+add_subdirectory(fast_float)
+target_link_libraries(myprogram PUBLIC fast_float)
+```
+
+Or you may want to retrieve the dependency automatically if you have a sufficiently recent version of CMake (3.11 or better at least):
+
+```cmake
+FetchContent_Declare(
+ fast_float
+ GIT_REPOSITORY https://github.com/lemire/fast_float.git
+ GIT_TAG tags/v1.1.2
+ GIT_SHALLOW TRUE)
+
+FetchContent_MakeAvailable(fast_float)
+target_link_libraries(myprogram PUBLIC fast_float)
+
+```
+
+You should change the `GIT_TAG` line so that you recover the version you wish to use.
+
+## Using as single header
+
+The script `script/amalgamate.py` may be used to generate a single header
+version of the library if so desired.
+Just run the script from the root directory of this repository.
+You can customize the license type and output file if desired as described in
+the command line help.
+
+You may directly download automatically generated single-header files:
+
+https://github.com/fastfloat/fast_float/releases/download/v1.1.2/fast_float.h
+
+## Credit
+
+Though this work is inspired by many different people, this work benefited especially from exchanges with
+Michael Eisel, who motivated the original research with his key insights, and with Nigel Tao who provided
+invaluable feedback. Rémy Oudompheng first implemented a fast path we use in the case of long digits.
+
+The library includes code adapted from Google Wuffs (written by Nigel Tao) which was originally published
+under the Apache 2.0 license.
+
+## License
+
+<sup>
+Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
+2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
+</sup>
+
+<br>
+
+<sub>
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in this repository by you, as defined in the Apache-2.0 license,
+shall be dual licensed as above, without any additional terms or conditions.
+</sub>
diff --git a/libstdc++-v3/src/c++17/fast_float/fast_float.h b/libstdc++-v3/src/c++17/fast_float/fast_float.h
new file mode 100644
index 00000000000..8a45ebca8a8
--- /dev/null
+++ b/libstdc++-v3/src/c++17/fast_float/fast_float.h
@@ -0,0 +1,2944 @@
+// fast_float by Daniel Lemire
+// fast_float by João Paulo Magalhaes
+//
+// with contributions from Eugene Golushkov
+// with contributions from Maksim Kita
+// with contributions from Marcin Wojdyr
+// with contributions from Neal Richardson
+// with contributions from Tim Paine
+// with contributions from Fabio Pellacini
+//
+// MIT License Notice
+//
+// MIT License
+//
+// Copyright (c) 2021 The fast_float authors
+//
+// Permission is hereby granted, free of charge, to any
+// person obtaining a copy of this software and associated
+// documentation files (the "Software"), to deal in the
+// Software without restriction, including without
+// limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software
+// is furnished to do so, subject to the following
+// conditions:
+//
+// The above copyright notice and this permission notice
+// shall be included in all copies or substantial portions
+// of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+//
+
+#ifndef FASTFLOAT_FAST_FLOAT_H
+#define FASTFLOAT_FAST_FLOAT_H
+
+#include <system_error>
+
+namespace fast_float {
+enum chars_format {
+ scientific = 1<<0,
+ fixed = 1<<2,
+ hex = 1<<3,
+ general = fixed | scientific
+};
+
+
+struct from_chars_result {
+ const char *ptr;
+ std::errc ec;
+};
+
+struct parse_options {
+ constexpr explicit parse_options(chars_format fmt = chars_format::general,
+ char dot = '.')
+ : format(fmt), decimal_point(dot) {}
+
+ /** Which number formats are accepted */
+ chars_format format;
+ /** The character used as decimal point */
+ char decimal_point;
+};
+
+/**
+ * This function parses the character sequence [first,last) for a number. It parses floating-point numbers expecting
+ * a locale-indepent format equivalent to what is used by std::strtod in the default ("C") locale.
+ * The resulting floating-point value is the closest floating-point values (using either float or double),
+ * using the "round to even" convention for values that would otherwise fall right in-between two values.
+ * That is, we provide exact parsing according to the IEEE standard.
+ *
+ * Given a successful parse, the pointer (`ptr`) in the returned value is set to point right after the
+ * parsed number, and the `value` referenced is set to the parsed value. In case of error, the returned
+ * `ec` contains a representative error, otherwise the default (`std::errc()`) value is stored.
+ *
+ * The implementation does not throw and does not allocate memory (e.g., with `new` or `malloc`).
+ *
+ * Like the C++17 standard, the `fast_float::from_chars` functions take an optional last argument of
+ * the type `fast_float::chars_format`. It is a bitset value: we check whether
+ * `fmt & fast_float::chars_format::fixed` and `fmt & fast_float::chars_format::scientific` are set
+ * to determine whether we allowe the fixed point and scientific notation respectively.
+ * The default is `fast_float::chars_format::general` which allows both `fixed` and `scientific`.
+ */
+template<typename T>
+from_chars_result from_chars(const char *first, const char *last,
+ T &value, chars_format fmt = chars_format::general) noexcept;
+
+/**
+ * Like from_chars, but accepts an `options` argument to govern number parsing.
+ */
+template<typename T>
+from_chars_result from_chars_advanced(const char *first, const char *last,
+ T &value, parse_options options) noexcept;
+
+}
+#endif // FASTFLOAT_FAST_FLOAT_H
+
+#ifndef FASTFLOAT_FLOAT_COMMON_H
+#define FASTFLOAT_FLOAT_COMMON_H
+
+#include <cfloat>
+#include <cstdint>
+#include <cassert>
+#include <cstring>
+
+#if (defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) \
+ || defined(__amd64) || defined(__aarch64__) || defined(_M_ARM64) \
+ || defined(__MINGW64__) \
+ || defined(__s390x__) \
+ || (defined(__ppc64__) || defined(__PPC64__) || defined(__ppc64le__) || defined(__PPC64LE__)) \
+ || defined(__EMSCRIPTEN__))
+#define FASTFLOAT_64BIT
+#elif (defined(__i386) || defined(__i386__) || defined(_M_IX86) \
+ || defined(__arm__) || defined(_M_ARM) \
+ || defined(__MINGW32__))
+#define FASTFLOAT_32BIT
+#else
+ // Need to check incrementally, since SIZE_MAX is a size_t, avoid overflow.
+ // We can never tell the register width, but the SIZE_MAX is a good approximation.
+ // UINTPTR_MAX and INTPTR_MAX are optional, so avoid them for max portability.
+ #if SIZE_MAX == 0xffff
+ #error Unknown platform (16-bit, unsupported)
+ #elif SIZE_MAX == 0xffffffff
+ #define FASTFLOAT_32BIT
+ #elif SIZE_MAX == 0xffffffffffffffff
+ #define FASTFLOAT_64BIT
+ #else
+ #error Unknown platform (not 32-bit, not 64-bit?)
+ #endif
+#endif
+
+#if ((defined(_WIN32) || defined(_WIN64)) && !defined(__clang__))
+#include <intrin.h>
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define FASTFLOAT_VISUAL_STUDIO 1
+#endif
+
+#ifdef _WIN32
+#define FASTFLOAT_IS_BIG_ENDIAN 0
+#else
+#if defined(__APPLE__) || defined(__FreeBSD__)
+#include <machine/endian.h>
+#elif defined(sun) || defined(__sun)
+#include <sys/byteorder.h>
+#else
+#include <endian.h>
+#endif
+#
+#ifndef __BYTE_ORDER__
+// safe choice
+#define FASTFLOAT_IS_BIG_ENDIAN 0
+#endif
+#
+#ifndef __ORDER_LITTLE_ENDIAN__
+// safe choice
+#define FASTFLOAT_IS_BIG_ENDIAN 0
+#endif
+#
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define FASTFLOAT_IS_BIG_ENDIAN 0
+#else
+#define FASTFLOAT_IS_BIG_ENDIAN 1
+#endif
+#endif
+
+#ifdef FASTFLOAT_VISUAL_STUDIO
+#define fastfloat_really_inline __forceinline
+#else
+#define fastfloat_really_inline inline __attribute__((always_inline))
+#endif
+
+#ifndef FASTFLOAT_ASSERT
+#define FASTFLOAT_ASSERT(x) { if (!(x)) abort(); }
+#endif
+
+#ifndef FASTFLOAT_DEBUG_ASSERT
+#include <cassert>
+#define FASTFLOAT_DEBUG_ASSERT(x) assert(x)
+#endif
+
+// rust style `try!()` macro, or `?` operator
+#define FASTFLOAT_TRY(x) { if (!(x)) return false; }
+
+namespace fast_float {
+
+// Compares two ASCII strings in a case insensitive manner.
+inline bool fastfloat_strncasecmp(const char *input1, const char *input2,
+ size_t length) {
+ char running_diff{0};
+ for (size_t i = 0; i < length; i++) {
+ running_diff |= (input1[i] ^ input2[i]);
+ }
+ return (running_diff == 0) || (running_diff == 32);
+}
+
+#ifndef FLT_EVAL_METHOD
+#error "FLT_EVAL_METHOD should be defined, please include cfloat."
+#endif
+
+// a pointer and a length to a contiguous block of memory
+template <typename T>
+struct span {
+ const T* ptr;
+ size_t length;
+ span(const T* _ptr, size_t _length) : ptr(_ptr), length(_length) {}
+ span() : ptr(nullptr), length(0) {}
+
+ constexpr size_t len() const noexcept {
+ return length;
+ }
+
+ const T& operator[](size_t index) const noexcept {
+ FASTFLOAT_DEBUG_ASSERT(index < length);
+ return ptr[index];
+ }
+};
+
+struct value128 {
+ uint64_t low;
+ uint64_t high;
+ value128(uint64_t _low, uint64_t _high) : low(_low), high(_high) {}
+ value128() : low(0), high(0) {}
+};
+
+/* result might be undefined when input_num is zero */
+fastfloat_really_inline int leading_zeroes(uint64_t input_num) {
+ assert(input_num > 0);
+#ifdef FASTFLOAT_VISUAL_STUDIO
+ #if defined(_M_X64) || defined(_M_ARM64)
+ unsigned long leading_zero = 0;
+ // Search the mask data from most significant bit (MSB)
+ // to least significant bit (LSB) for a set bit (1).
+ _BitScanReverse64(&leading_zero, input_num);
+ return (int)(63 - leading_zero);
+ #else
+ int last_bit = 0;
+ if(input_num & uint64_t(0xffffffff00000000)) input_num >>= 32, last_bit |= 32;
+ if(input_num & uint64_t( 0xffff0000)) input_num >>= 16, last_bit |= 16;
+ if(input_num & uint64_t( 0xff00)) input_num >>= 8, last_bit |= 8;
+ if(input_num & uint64_t( 0xf0)) input_num >>= 4, last_bit |= 4;
+ if(input_num & uint64_t( 0xc)) input_num >>= 2, last_bit |= 2;
+ if(input_num & uint64_t( 0x2)) input_num >>= 1, last_bit |= 1;
+ return 63 - last_bit;
+ #endif
+#else
+ return __builtin_clzll(input_num);
+#endif
+}
+
+#ifdef FASTFLOAT_32BIT
+
+// slow emulation routine for 32-bit
+fastfloat_really_inline uint64_t emulu(uint32_t x, uint32_t y) {
+ return x * (uint64_t)y;
+}
+
+// slow emulation routine for 32-bit
+#if !defined(__MINGW64__)
+fastfloat_really_inline uint64_t _umul128(uint64_t ab, uint64_t cd,
+ uint64_t *hi) {
+ uint64_t ad = emulu((uint32_t)(ab >> 32), (uint32_t)cd);
+ uint64_t bd = emulu((uint32_t)ab, (uint32_t)cd);
+ uint64_t adbc = ad + emulu((uint32_t)ab, (uint32_t)(cd >> 32));
+ uint64_t adbc_carry = !!(adbc < ad);
+ uint64_t lo = bd + (adbc << 32);
+ *hi = emulu((uint32_t)(ab >> 32), (uint32_t)(cd >> 32)) + (adbc >> 32) +
+ (adbc_carry << 32) + !!(lo < bd);
+ return lo;
+}
+#endif // !__MINGW64__
+
+#endif // FASTFLOAT_32BIT
+
+
+// compute 64-bit a*b
+fastfloat_really_inline value128 full_multiplication(uint64_t a,
+ uint64_t b) {
+ value128 answer;
+#ifdef _M_ARM64
+ // ARM64 has native support for 64-bit multiplications, no need to emulate
+ answer.high = __umulh(a, b);
+ answer.low = a * b;
+#elif defined(FASTFLOAT_32BIT) || (defined(_WIN64) && !defined(__clang__))
+ answer.low = _umul128(a, b, &answer.high); // _umul128 not available on ARM64
+#elif defined(FASTFLOAT_64BIT)
+ __uint128_t r = ((__uint128_t)a) * b;
+ answer.low = uint64_t(r);
+ answer.high = uint64_t(r >> 64);
+#else
+ #error Not implemented
+#endif
+ return answer;
+}
+
+struct adjusted_mantissa {
+ uint64_t mantissa{0};
+ int32_t power2{0}; // a negative value indicates an invalid result
+ adjusted_mantissa() = default;
+ bool operator==(const adjusted_mantissa &o) const {
+ return mantissa == o.mantissa && power2 == o.power2;
+ }
+ bool operator!=(const adjusted_mantissa &o) const {
+ return mantissa != o.mantissa || power2 != o.power2;
+ }
+};
+
+// Bias so we can get the real exponent with an invalid adjusted_mantissa.
+constexpr static int32_t invalid_am_bias = -0x8000;
+
+constexpr static double powers_of_ten_double[] = {
+ 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11,
+ 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};
+constexpr static float powers_of_ten_float[] = {1e0, 1e1, 1e2, 1e3, 1e4, 1e5,
+ 1e6, 1e7, 1e8, 1e9, 1e10};
+
+template <typename T> struct binary_format {
+ static inline constexpr int mantissa_explicit_bits();
+ static inline constexpr int minimum_exponent();
+ static inline constexpr int infinite_power();
+ static inline constexpr int sign_index();
+ static inline constexpr int min_exponent_fast_path();
+ static inline constexpr int max_exponent_fast_path();
+ static inline constexpr int max_exponent_round_to_even();
+ static inline constexpr int min_exponent_round_to_even();
+ static inline constexpr uint64_t max_mantissa_fast_path();
+ static inline constexpr int largest_power_of_ten();
+ static inline constexpr int smallest_power_of_ten();
+ static inline constexpr T exact_power_of_ten(int64_t power);
+ static inline constexpr size_t max_digits();
+};
+
+template <> inline constexpr int binary_format<double>::mantissa_explicit_bits() {
+ return 52;
+}
+template <> inline constexpr int binary_format<float>::mantissa_explicit_bits() {
+ return 23;
+}
+
+template <> inline constexpr int binary_format<double>::max_exponent_round_to_even() {
+ return 23;
+}
+
+template <> inline constexpr int binary_format<float>::max_exponent_round_to_even() {
+ return 10;
+}
+
+template <> inline constexpr int binary_format<double>::min_exponent_round_to_even() {
+ return -4;
+}
+
+template <> inline constexpr int binary_format<float>::min_exponent_round_to_even() {
+ return -17;
+}
+
+template <> inline constexpr int binary_format<double>::minimum_exponent() {
+ return -1023;
+}
+template <> inline constexpr int binary_format<float>::minimum_exponent() {
+ return -127;
+}
+
+template <> inline constexpr int binary_format<double>::infinite_power() {
+ return 0x7FF;
+}
+template <> inline constexpr int binary_format<float>::infinite_power() {
+ return 0xFF;
+}
+
+template <> inline constexpr int binary_format<double>::sign_index() { return 63; }
+template <> inline constexpr int binary_format<float>::sign_index() { return 31; }
+
+template <> inline constexpr int binary_format<double>::min_exponent_fast_path() {
+#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
+ return 0;
+#else
+ return -22;
+#endif
+}
+template <> inline constexpr int binary_format<float>::min_exponent_fast_path() {
+#if (FLT_EVAL_METHOD != 1) && (FLT_EVAL_METHOD != 0)
+ return 0;
+#else
+ return -10;
+#endif
+}
+
+template <> inline constexpr int binary_format<double>::max_exponent_fast_path() {
+ return 22;
+}
+template <> inline constexpr int binary_format<float>::max_exponent_fast_path() {
+ return 10;
+}
+
+template <> inline constexpr uint64_t binary_format<double>::max_mantissa_fast_path() {
+ return uint64_t(2) << mantissa_explicit_bits();
+}
+template <> inline constexpr uint64_t binary_format<float>::max_mantissa_fast_path() {
+ return uint64_t(2) << mantissa_explicit_bits();
+}
+
+template <>
+inline constexpr double binary_format<double>::exact_power_of_ten(int64_t power) {
+ return powers_of_ten_double[power];
+}
+template <>
+inline constexpr float binary_format<float>::exact_power_of_ten(int64_t power) {
+
+ return powers_of_ten_float[power];
+}
+
+
+template <>
+inline constexpr int binary_format<double>::largest_power_of_ten() {
+ return 308;
+}
+template <>
+inline constexpr int binary_format<float>::largest_power_of_ten() {
+ return 38;
+}
+
+template <>
+inline constexpr int binary_format<double>::smallest_power_of_ten() {
+ return -342;
+}
+template <>
+inline constexpr int binary_format<float>::smallest_power_of_ten() {
+ return -65;
+}
+
+template <> inline constexpr size_t binary_format<double>::max_digits() {
+ return 769;
+}
+template <> inline constexpr size_t binary_format<float>::max_digits() {
+ return 114;
+}
+
+template<typename T>
+fastfloat_really_inline void to_float(bool negative, adjusted_mantissa am, T &value) {
+ uint64_t word = am.mantissa;
+ word |= uint64_t(am.power2) << binary_format<T>::mantissa_explicit_bits();
+ word = negative
+ ? word | (uint64_t(1) << binary_format<T>::sign_index()) : word;
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+ if (std::is_same<T, float>::value) {
+ ::memcpy(&value, (char *)&word + 4, sizeof(T)); // extract value at offset 4-7 if float on big-endian
+ } else {
+ ::memcpy(&value, &word, sizeof(T));
+ }
+#else
+ // For little-endian systems:
+ ::memcpy(&value, &word, sizeof(T));
+#endif
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_ASCII_NUMBER_H
+#define FASTFLOAT_ASCII_NUMBER_H
+
+#include <cctype>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+
+
+namespace fast_float {
+
+// Next function can be micro-optimized, but compilers are entirely
+// able to optimize it well.
+fastfloat_really_inline bool is_integer(char c) noexcept { return c >= '0' && c <= '9'; }
+
+fastfloat_really_inline uint64_t byteswap(uint64_t val) {
+ return (val & 0xFF00000000000000) >> 56
+ | (val & 0x00FF000000000000) >> 40
+ | (val & 0x0000FF0000000000) >> 24
+ | (val & 0x000000FF00000000) >> 8
+ | (val & 0x00000000FF000000) << 8
+ | (val & 0x0000000000FF0000) << 24
+ | (val & 0x000000000000FF00) << 40
+ | (val & 0x00000000000000FF) << 56;
+}
+
+fastfloat_really_inline uint64_t read_u64(const char *chars) {
+ uint64_t val;
+ ::memcpy(&val, chars, sizeof(uint64_t));
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+ // Need to read as-if the number was in little-endian order.
+ val = byteswap(val);
+#endif
+ return val;
+}
+
+fastfloat_really_inline void write_u64(uint8_t *chars, uint64_t val) {
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+ // Need to read as-if the number was in little-endian order.
+ val = byteswap(val);
+#endif
+ ::memcpy(chars, &val, sizeof(uint64_t));
+}
+
+// credit @aqrit
+fastfloat_really_inline uint32_t parse_eight_digits_unrolled(uint64_t val) {
+ const uint64_t mask = 0x000000FF000000FF;
+ const uint64_t mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
+ const uint64_t mul2 = 0x0000271000000001; // 1 + (10000ULL << 32)
+ val -= 0x3030303030303030;
+ val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8;
+ val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32;
+ return uint32_t(val);
+}
+
+fastfloat_really_inline uint32_t parse_eight_digits_unrolled(const char *chars) noexcept {
+ return parse_eight_digits_unrolled(read_u64(chars));
+}
+
+// credit @aqrit
+fastfloat_really_inline bool is_made_of_eight_digits_fast(uint64_t val) noexcept {
+ return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
+ 0x8080808080808080));
+}
+
+fastfloat_really_inline bool is_made_of_eight_digits_fast(const char *chars) noexcept {
+ return is_made_of_eight_digits_fast(read_u64(chars));
+}
+
+typedef span<const char> byte_span;
+
+struct parsed_number_string {
+ int64_t exponent{0};
+ uint64_t mantissa{0};
+ const char *lastmatch{nullptr};
+ bool negative{false};
+ bool valid{false};
+ bool too_many_digits{false};
+ // contains the range of the significant digits
+ byte_span integer{}; // non-nullable
+ byte_span fraction{}; // nullable
+};
+
+// Assuming that you use no more than 19 digits, this will
+// parse an ASCII string.
+fastfloat_really_inline
+parsed_number_string parse_number_string(const char *p, const char *pend, parse_options options) noexcept {
+ const chars_format fmt = options.format;
+ const char decimal_point = options.decimal_point;
+
+ parsed_number_string answer;
+ answer.valid = false;
+ answer.too_many_digits = false;
+ answer.negative = (*p == '-');
+ if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
+ ++p;
+ if (p == pend) {
+ return answer;
+ }
+ if (!is_integer(*p) && (*p != decimal_point)) { // a sign must be followed by an integer or the dot
+ return answer;
+ }
+ }
+ const char *const start_digits = p;
+
+ uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
+
+ while ((std::distance(p, pend) >= 8) && is_made_of_eight_digits_fast(p)) {
+ i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
+ p += 8;
+ }
+ while ((p != pend) && is_integer(*p)) {
+ // a multiplication by 10 is cheaper than an arbitrary integer
+ // multiplication
+ i = 10 * i +
+ uint64_t(*p - '0'); // might overflow, we will handle the overflow later
+ ++p;
+ }
+ const char *const end_of_integer_part = p;
+ int64_t digit_count = int64_t(end_of_integer_part - start_digits);
+ answer.integer = byte_span(start_digits, size_t(digit_count));
+ int64_t exponent = 0;
+ if ((p != pend) && (*p == decimal_point)) {
+ ++p;
+ const char* before = p;
+ // can occur at most twice without overflowing, but let it occur more, since
+ // for integers with many digits, digit parsing is the primary bottleneck.
+ while ((std::distance(p, pend) >= 8) && is_made_of_eight_digits_fast(p)) {
+ i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
+ p += 8;
+ }
+ while ((p != pend) && is_integer(*p)) {
+ uint8_t digit = uint8_t(*p - '0');
+ ++p;
+ i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
+ }
+ exponent = before - p;
+ answer.fraction = byte_span(before, size_t(p - before));
+ digit_count -= exponent;
+ }
+ // we must have encountered at least one integer!
+ if (digit_count == 0) {
+ return answer;
+ }
+ int64_t exp_number = 0; // explicit exponential part
+ if ((fmt & chars_format::scientific) && (p != pend) && (('e' == *p) || ('E' == *p))) {
+ const char * location_of_e = p;
+ ++p;
+ bool neg_exp = false;
+ if ((p != pend) && ('-' == *p)) {
+ neg_exp = true;
+ ++p;
+ } else if ((p != pend) && ('+' == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
+ ++p;
+ }
+ if ((p == pend) || !is_integer(*p)) {
+ if(!(fmt & chars_format::fixed)) {
+ // We are in error.
+ return answer;
+ }
+ // Otherwise, we will be ignoring the 'e'.
+ p = location_of_e;
+ } else {
+ while ((p != pend) && is_integer(*p)) {
+ uint8_t digit = uint8_t(*p - '0');
+ if (exp_number < 0x10000000) {
+ exp_number = 10 * exp_number + digit;
+ }
+ ++p;
+ }
+ if(neg_exp) { exp_number = - exp_number; }
+ exponent += exp_number;
+ }
+ } else {
+ // If it scientific and not fixed, we have to bail out.
+ if((fmt & chars_format::scientific) && !(fmt & chars_format::fixed)) { return answer; }
+ }
+ answer.lastmatch = p;
+ answer.valid = true;
+
+ // If we frequently had to deal with long strings of digits,
+ // we could extend our code by using a 128-bit integer instead
+ // of a 64-bit integer. However, this is uncommon.
+ //
+ // We can deal with up to 19 digits.
+ if (digit_count > 19) { // this is uncommon
+ // It is possible that the integer had an overflow.
+ // We have to handle the case where we have 0.0000somenumber.
+ // We need to be mindful of the case where we only have zeroes...
+ // E.g., 0.000000000...000.
+ const char *start = start_digits;
+ while ((start != pend) && (*start == '0' || *start == decimal_point)) {
+ if(*start == '0') { digit_count --; }
+ start++;
+ }
+ if (digit_count > 19) {
+ answer.too_many_digits = true;
+ // Let us start again, this time, avoiding overflows.
+ // We don't need to check if is_integer, since we use the
+ // pre-tokenized spans from above.
+ i = 0;
+ p = answer.integer.ptr;
+ const char* int_end = p + answer.integer.len();
+ const uint64_t minimal_nineteen_digit_integer{1000000000000000000};
+ while((i < minimal_nineteen_digit_integer) && (p != int_end)) {
+ i = i * 10 + uint64_t(*p - '0');
+ ++p;
+ }
+ if (i >= minimal_nineteen_digit_integer) { // We have a big integers
+ exponent = end_of_integer_part - p + exp_number;
+ } else { // We have a value with a fractional component.
+ p = answer.fraction.ptr;
+ const char* frac_end = p + answer.fraction.len();
+ while((i < minimal_nineteen_digit_integer) && (p != frac_end)) {
+ i = i * 10 + uint64_t(*p - '0');
+ ++p;
+ }
+ exponent = answer.fraction.ptr - p + exp_number;
+ }
+ // We have now corrected both exponent and i, to a truncated value
+ }
+ }
+ answer.exponent = exponent;
+ answer.mantissa = i;
+ return answer;
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_FAST_TABLE_H
+#define FASTFLOAT_FAST_TABLE_H
+
+#include <cstdint>
+
+namespace fast_float {
+
+/**
+ * When mapping numbers from decimal to binary,
+ * we go from w * 10^q to m * 2^p but we have
+ * 10^q = 5^q * 2^q, so effectively
+ * we are trying to match
+ * w * 2^q * 5^q to m * 2^p. Thus the powers of two
+ * are not a concern since they can be represented
+ * exactly using the binary notation, only the powers of five
+ * affect the binary significand.
+ */
+
+/**
+ * The smallest non-zero float (binary64) is 2^−1074.
+ * We take as input numbers of the form w x 10^q where w < 2^64.
+ * We have that w * 10^-343 < 2^(64-344) 5^-343 < 2^-1076.
+ * However, we have that
+ * (2^64-1) * 10^-342 = (2^64-1) * 2^-342 * 5^-342 > 2^−1074.
+ * Thus it is possible for a number of the form w * 10^-342 where
+ * w is a 64-bit value to be a non-zero floating-point number.
+ *********
+ * Any number of form w * 10^309 where w>= 1 is going to be
+ * infinite in binary64 so we never need to worry about powers
+ * of 5 greater than 308.
+ */
+template <class unused = void>
+struct powers_template {
+
+constexpr static int smallest_power_of_five = binary_format<double>::smallest_power_of_ten();
+constexpr static int largest_power_of_five = binary_format<double>::largest_power_of_ten();
+constexpr static int number_of_entries = 2 * (largest_power_of_five - smallest_power_of_five + 1);
+// Powers of five from 5^-342 all the way to 5^308 rounded toward one.
+static const uint64_t power_of_five_128[number_of_entries];
+};
+
+template <class unused>
+const uint64_t powers_template<unused>::power_of_five_128[number_of_entries] = {
+ 0xeef453d6923bd65a,0x113faa2906a13b3f,
+ 0x9558b4661b6565f8,0x4ac7ca59a424c507,
+ 0xbaaee17fa23ebf76,0x5d79bcf00d2df649,
+ 0xe95a99df8ace6f53,0xf4d82c2c107973dc,
+ 0x91d8a02bb6c10594,0x79071b9b8a4be869,
+ 0xb64ec836a47146f9,0x9748e2826cdee284,
+ 0xe3e27a444d8d98b7,0xfd1b1b2308169b25,
+ 0x8e6d8c6ab0787f72,0xfe30f0f5e50e20f7,
+ 0xb208ef855c969f4f,0xbdbd2d335e51a935,
+ 0xde8b2b66b3bc4723,0xad2c788035e61382,
+ 0x8b16fb203055ac76,0x4c3bcb5021afcc31,
+ 0xaddcb9e83c6b1793,0xdf4abe242a1bbf3d,
+ 0xd953e8624b85dd78,0xd71d6dad34a2af0d,
+ 0x87d4713d6f33aa6b,0x8672648c40e5ad68,
+ 0xa9c98d8ccb009506,0x680efdaf511f18c2,
+ 0xd43bf0effdc0ba48,0x212bd1b2566def2,
+ 0x84a57695fe98746d,0x14bb630f7604b57,
+ 0xa5ced43b7e3e9188,0x419ea3bd35385e2d,
+ 0xcf42894a5dce35ea,0x52064cac828675b9,
+ 0x818995ce7aa0e1b2,0x7343efebd1940993,
+ 0xa1ebfb4219491a1f,0x1014ebe6c5f90bf8,
+ 0xca66fa129f9b60a6,0xd41a26e077774ef6,
+ 0xfd00b897478238d0,0x8920b098955522b4,
+ 0x9e20735e8cb16382,0x55b46e5f5d5535b0,
+ 0xc5a890362fddbc62,0xeb2189f734aa831d,
+ 0xf712b443bbd52b7b,0xa5e9ec7501d523e4,
+ 0x9a6bb0aa55653b2d,0x47b233c92125366e,
+ 0xc1069cd4eabe89f8,0x999ec0bb696e840a,
+ 0xf148440a256e2c76,0xc00670ea43ca250d,
+ 0x96cd2a865764dbca,0x380406926a5e5728,
+ 0xbc807527ed3e12bc,0xc605083704f5ecf2,
+ 0xeba09271e88d976b,0xf7864a44c633682e,
+ 0x93445b8731587ea3,0x7ab3ee6afbe0211d,
+ 0xb8157268fdae9e4c,0x5960ea05bad82964,
+ 0xe61acf033d1a45df,0x6fb92487298e33bd,
+ 0x8fd0c16206306bab,0xa5d3b6d479f8e056,
+ 0xb3c4f1ba87bc8696,0x8f48a4899877186c,
+ 0xe0b62e2929aba83c,0x331acdabfe94de87,
+ 0x8c71dcd9ba0b4925,0x9ff0c08b7f1d0b14,
+ 0xaf8e5410288e1b6f,0x7ecf0ae5ee44dd9,
+ 0xdb71e91432b1a24a,0xc9e82cd9f69d6150,
+ 0x892731ac9faf056e,0xbe311c083a225cd2,
+ 0xab70fe17c79ac6ca,0x6dbd630a48aaf406,
+ 0xd64d3d9db981787d,0x92cbbccdad5b108,
+ 0x85f0468293f0eb4e,0x25bbf56008c58ea5,
+ 0xa76c582338ed2621,0xaf2af2b80af6f24e,
+ 0xd1476e2c07286faa,0x1af5af660db4aee1,
+ 0x82cca4db847945ca,0x50d98d9fc890ed4d,
+ 0xa37fce126597973c,0xe50ff107bab528a0,
+ 0xcc5fc196fefd7d0c,0x1e53ed49a96272c8,
+ 0xff77b1fcbebcdc4f,0x25e8e89c13bb0f7a,
+ 0x9faacf3df73609b1,0x77b191618c54e9ac,
+ 0xc795830d75038c1d,0xd59df5b9ef6a2417,
+ 0xf97ae3d0d2446f25,0x4b0573286b44ad1d,
+ 0x9becce62836ac577,0x4ee367f9430aec32,
+ 0xc2e801fb244576d5,0x229c41f793cda73f,
+ 0xf3a20279ed56d48a,0x6b43527578c1110f,
+ 0x9845418c345644d6,0x830a13896b78aaa9,
+ 0xbe5691ef416bd60c,0x23cc986bc656d553,
+ 0xedec366b11c6cb8f,0x2cbfbe86b7ec8aa8,
+ 0x94b3a202eb1c3f39,0x7bf7d71432f3d6a9,
+ 0xb9e08a83a5e34f07,0xdaf5ccd93fb0cc53,
+ 0xe858ad248f5c22c9,0xd1b3400f8f9cff68,
+ 0x91376c36d99995be,0x23100809b9c21fa1,
+ 0xb58547448ffffb2d,0xabd40a0c2832a78a,
+ 0xe2e69915b3fff9f9,0x16c90c8f323f516c,
+ 0x8dd01fad907ffc3b,0xae3da7d97f6792e3,
+ 0xb1442798f49ffb4a,0x99cd11cfdf41779c,
+ 0xdd95317f31c7fa1d,0x40405643d711d583,
+ 0x8a7d3eef7f1cfc52,0x482835ea666b2572,
+ 0xad1c8eab5ee43b66,0xda3243650005eecf,
+ 0xd863b256369d4a40,0x90bed43e40076a82,
+ 0x873e4f75e2224e68,0x5a7744a6e804a291,
+ 0xa90de3535aaae202,0x711515d0a205cb36,
+ 0xd3515c2831559a83,0xd5a5b44ca873e03,
+ 0x8412d9991ed58091,0xe858790afe9486c2,
+ 0xa5178fff668ae0b6,0x626e974dbe39a872,
+ 0xce5d73ff402d98e3,0xfb0a3d212dc8128f,
+ 0x80fa687f881c7f8e,0x7ce66634bc9d0b99,
+ 0xa139029f6a239f72,0x1c1fffc1ebc44e80,
+ 0xc987434744ac874e,0xa327ffb266b56220,
+ 0xfbe9141915d7a922,0x4bf1ff9f0062baa8,
+ 0x9d71ac8fada6c9b5,0x6f773fc3603db4a9,
+ 0xc4ce17b399107c22,0xcb550fb4384d21d3,
+ 0xf6019da07f549b2b,0x7e2a53a146606a48,
+ 0x99c102844f94e0fb,0x2eda7444cbfc426d,
+ 0xc0314325637a1939,0xfa911155fefb5308,
+ 0xf03d93eebc589f88,0x793555ab7eba27ca,
+ 0x96267c7535b763b5,0x4bc1558b2f3458de,
+ 0xbbb01b9283253ca2,0x9eb1aaedfb016f16,
+ 0xea9c227723ee8bcb,0x465e15a979c1cadc,
+ 0x92a1958a7675175f,0xbfacd89ec191ec9,
+ 0xb749faed14125d36,0xcef980ec671f667b,
+ 0xe51c79a85916f484,0x82b7e12780e7401a,
+ 0x8f31cc0937ae58d2,0xd1b2ecb8b0908810,
+ 0xb2fe3f0b8599ef07,0x861fa7e6dcb4aa15,
+ 0xdfbdcece67006ac9,0x67a791e093e1d49a,
+ 0x8bd6a141006042bd,0xe0c8bb2c5c6d24e0,
+ 0xaecc49914078536d,0x58fae9f773886e18,
+ 0xda7f5bf590966848,0xaf39a475506a899e,
+ 0x888f99797a5e012d,0x6d8406c952429603,
+ 0xaab37fd7d8f58178,0xc8e5087ba6d33b83,
+ 0xd5605fcdcf32e1d6,0xfb1e4a9a90880a64,
+ 0x855c3be0a17fcd26,0x5cf2eea09a55067f,
+ 0xa6b34ad8c9dfc06f,0xf42faa48c0ea481e,
+ 0xd0601d8efc57b08b,0xf13b94daf124da26,
+ 0x823c12795db6ce57,0x76c53d08d6b70858,
+ 0xa2cb1717b52481ed,0x54768c4b0c64ca6e,
+ 0xcb7ddcdda26da268,0xa9942f5dcf7dfd09,
+ 0xfe5d54150b090b02,0xd3f93b35435d7c4c,
+ 0x9efa548d26e5a6e1,0xc47bc5014a1a6daf,
+ 0xc6b8e9b0709f109a,0x359ab6419ca1091b,
+ 0xf867241c8cc6d4c0,0xc30163d203c94b62,
+ 0x9b407691d7fc44f8,0x79e0de63425dcf1d,
+ 0xc21094364dfb5636,0x985915fc12f542e4,
+ 0xf294b943e17a2bc4,0x3e6f5b7b17b2939d,
+ 0x979cf3ca6cec5b5a,0xa705992ceecf9c42,
+ 0xbd8430bd08277231,0x50c6ff782a838353,
+ 0xece53cec4a314ebd,0xa4f8bf5635246428,
+ 0x940f4613ae5ed136,0x871b7795e136be99,
+ 0xb913179899f68584,0x28e2557b59846e3f,
+ 0xe757dd7ec07426e5,0x331aeada2fe589cf,
+ 0x9096ea6f3848984f,0x3ff0d2c85def7621,
+ 0xb4bca50b065abe63,0xfed077a756b53a9,
+ 0xe1ebce4dc7f16dfb,0xd3e8495912c62894,
+ 0x8d3360f09cf6e4bd,0x64712dd7abbbd95c,
+ 0xb080392cc4349dec,0xbd8d794d96aacfb3,
+ 0xdca04777f541c567,0xecf0d7a0fc5583a0,
+ 0x89e42caaf9491b60,0xf41686c49db57244,
+ 0xac5d37d5b79b6239,0x311c2875c522ced5,
+ 0xd77485cb25823ac7,0x7d633293366b828b,
+ 0x86a8d39ef77164bc,0xae5dff9c02033197,
+ 0xa8530886b54dbdeb,0xd9f57f830283fdfc,
+ 0xd267caa862a12d66,0xd072df63c324fd7b,
+ 0x8380dea93da4bc60,0x4247cb9e59f71e6d,
+ 0xa46116538d0deb78,0x52d9be85f074e608,
+ 0xcd795be870516656,0x67902e276c921f8b,
+ 0x806bd9714632dff6,0xba1cd8a3db53b6,
+ 0xa086cfcd97bf97f3,0x80e8a40eccd228a4,
+ 0xc8a883c0fdaf7df0,0x6122cd128006b2cd,
+ 0xfad2a4b13d1b5d6c,0x796b805720085f81,
+ 0x9cc3a6eec6311a63,0xcbe3303674053bb0,
+ 0xc3f490aa77bd60fc,0xbedbfc4411068a9c,
+ 0xf4f1b4d515acb93b,0xee92fb5515482d44,
+ 0x991711052d8bf3c5,0x751bdd152d4d1c4a,
+ 0xbf5cd54678eef0b6,0xd262d45a78a0635d,
+ 0xef340a98172aace4,0x86fb897116c87c34,
+ 0x9580869f0e7aac0e,0xd45d35e6ae3d4da0,
+ 0xbae0a846d2195712,0x8974836059cca109,
+ 0xe998d258869facd7,0x2bd1a438703fc94b,
+ 0x91ff83775423cc06,0x7b6306a34627ddcf,
+ 0xb67f6455292cbf08,0x1a3bc84c17b1d542,
+ 0xe41f3d6a7377eeca,0x20caba5f1d9e4a93,
+ 0x8e938662882af53e,0x547eb47b7282ee9c,
+ 0xb23867fb2a35b28d,0xe99e619a4f23aa43,
+ 0xdec681f9f4c31f31,0x6405fa00e2ec94d4,
+ 0x8b3c113c38f9f37e,0xde83bc408dd3dd04,
+ 0xae0b158b4738705e,0x9624ab50b148d445,
+ 0xd98ddaee19068c76,0x3badd624dd9b0957,
+ 0x87f8a8d4cfa417c9,0xe54ca5d70a80e5d6,
+ 0xa9f6d30a038d1dbc,0x5e9fcf4ccd211f4c,
+ 0xd47487cc8470652b,0x7647c3200069671f,
+ 0x84c8d4dfd2c63f3b,0x29ecd9f40041e073,
+ 0xa5fb0a17c777cf09,0xf468107100525890,
+ 0xcf79cc9db955c2cc,0x7182148d4066eeb4,
+ 0x81ac1fe293d599bf,0xc6f14cd848405530,
+ 0xa21727db38cb002f,0xb8ada00e5a506a7c,
+ 0xca9cf1d206fdc03b,0xa6d90811f0e4851c,
+ 0xfd442e4688bd304a,0x908f4a166d1da663,
+ 0x9e4a9cec15763e2e,0x9a598e4e043287fe,
+ 0xc5dd44271ad3cdba,0x40eff1e1853f29fd,
+ 0xf7549530e188c128,0xd12bee59e68ef47c,
+ 0x9a94dd3e8cf578b9,0x82bb74f8301958ce,
+ 0xc13a148e3032d6e7,0xe36a52363c1faf01,
+ 0xf18899b1bc3f8ca1,0xdc44e6c3cb279ac1,
+ 0x96f5600f15a7b7e5,0x29ab103a5ef8c0b9,
+ 0xbcb2b812db11a5de,0x7415d448f6b6f0e7,
+ 0xebdf661791d60f56,0x111b495b3464ad21,
+ 0x936b9fcebb25c995,0xcab10dd900beec34,
+ 0xb84687c269ef3bfb,0x3d5d514f40eea742,
+ 0xe65829b3046b0afa,0xcb4a5a3112a5112,
+ 0x8ff71a0fe2c2e6dc,0x47f0e785eaba72ab,
+ 0xb3f4e093db73a093,0x59ed216765690f56,
+ 0xe0f218b8d25088b8,0x306869c13ec3532c,
+ 0x8c974f7383725573,0x1e414218c73a13fb,
+ 0xafbd2350644eeacf,0xe5d1929ef90898fa,
+ 0xdbac6c247d62a583,0xdf45f746b74abf39,
+ 0x894bc396ce5da772,0x6b8bba8c328eb783,
+ 0xab9eb47c81f5114f,0x66ea92f3f326564,
+ 0xd686619ba27255a2,0xc80a537b0efefebd,
+ 0x8613fd0145877585,0xbd06742ce95f5f36,
+ 0xa798fc4196e952e7,0x2c48113823b73704,
+ 0xd17f3b51fca3a7a0,0xf75a15862ca504c5,
+ 0x82ef85133de648c4,0x9a984d73dbe722fb,
+ 0xa3ab66580d5fdaf5,0xc13e60d0d2e0ebba,
+ 0xcc963fee10b7d1b3,0x318df905079926a8,
+ 0xffbbcfe994e5c61f,0xfdf17746497f7052,
+ 0x9fd561f1fd0f9bd3,0xfeb6ea8bedefa633,
+ 0xc7caba6e7c5382c8,0xfe64a52ee96b8fc0,
+ 0xf9bd690a1b68637b,0x3dfdce7aa3c673b0,
+ 0x9c1661a651213e2d,0x6bea10ca65c084e,
+ 0xc31bfa0fe5698db8,0x486e494fcff30a62,
+ 0xf3e2f893dec3f126,0x5a89dba3c3efccfa,
+ 0x986ddb5c6b3a76b7,0xf89629465a75e01c,
+ 0xbe89523386091465,0xf6bbb397f1135823,
+ 0xee2ba6c0678b597f,0x746aa07ded582e2c,
+ 0x94db483840b717ef,0xa8c2a44eb4571cdc,
+ 0xba121a4650e4ddeb,0x92f34d62616ce413,
+ 0xe896a0d7e51e1566,0x77b020baf9c81d17,
+ 0x915e2486ef32cd60,0xace1474dc1d122e,
+ 0xb5b5ada8aaff80b8,0xd819992132456ba,
+ 0xe3231912d5bf60e6,0x10e1fff697ed6c69,
+ 0x8df5efabc5979c8f,0xca8d3ffa1ef463c1,
+ 0xb1736b96b6fd83b3,0xbd308ff8a6b17cb2,
+ 0xddd0467c64bce4a0,0xac7cb3f6d05ddbde,
+ 0x8aa22c0dbef60ee4,0x6bcdf07a423aa96b,
+ 0xad4ab7112eb3929d,0x86c16c98d2c953c6,
+ 0xd89d64d57a607744,0xe871c7bf077ba8b7,
+ 0x87625f056c7c4a8b,0x11471cd764ad4972,
+ 0xa93af6c6c79b5d2d,0xd598e40d3dd89bcf,
+ 0xd389b47879823479,0x4aff1d108d4ec2c3,
+ 0x843610cb4bf160cb,0xcedf722a585139ba,
+ 0xa54394fe1eedb8fe,0xc2974eb4ee658828,
+ 0xce947a3da6a9273e,0x733d226229feea32,
+ 0x811ccc668829b887,0x806357d5a3f525f,
+ 0xa163ff802a3426a8,0xca07c2dcb0cf26f7,
+ 0xc9bcff6034c13052,0xfc89b393dd02f0b5,
+ 0xfc2c3f3841f17c67,0xbbac2078d443ace2,
+ 0x9d9ba7832936edc0,0xd54b944b84aa4c0d,
+ 0xc5029163f384a931,0xa9e795e65d4df11,
+ 0xf64335bcf065d37d,0x4d4617b5ff4a16d5,
+ 0x99ea0196163fa42e,0x504bced1bf8e4e45,
+ 0xc06481fb9bcf8d39,0xe45ec2862f71e1d6,
+ 0xf07da27a82c37088,0x5d767327bb4e5a4c,
+ 0x964e858c91ba2655,0x3a6a07f8d510f86f,
+ 0xbbe226efb628afea,0x890489f70a55368b,
+ 0xeadab0aba3b2dbe5,0x2b45ac74ccea842e,
+ 0x92c8ae6b464fc96f,0x3b0b8bc90012929d,
+ 0xb77ada0617e3bbcb,0x9ce6ebb40173744,
+ 0xe55990879ddcaabd,0xcc420a6a101d0515,
+ 0x8f57fa54c2a9eab6,0x9fa946824a12232d,
+ 0xb32df8e9f3546564,0x47939822dc96abf9,
+ 0xdff9772470297ebd,0x59787e2b93bc56f7,
+ 0x8bfbea76c619ef36,0x57eb4edb3c55b65a,
+ 0xaefae51477a06b03,0xede622920b6b23f1,
+ 0xdab99e59958885c4,0xe95fab368e45eced,
+ 0x88b402f7fd75539b,0x11dbcb0218ebb414,
+ 0xaae103b5fcd2a881,0xd652bdc29f26a119,
+ 0xd59944a37c0752a2,0x4be76d3346f0495f,
+ 0x857fcae62d8493a5,0x6f70a4400c562ddb,
+ 0xa6dfbd9fb8e5b88e,0xcb4ccd500f6bb952,
+ 0xd097ad07a71f26b2,0x7e2000a41346a7a7,
+ 0x825ecc24c873782f,0x8ed400668c0c28c8,
+ 0xa2f67f2dfa90563b,0x728900802f0f32fa,
+ 0xcbb41ef979346bca,0x4f2b40a03ad2ffb9,
+ 0xfea126b7d78186bc,0xe2f610c84987bfa8,
+ 0x9f24b832e6b0f436,0xdd9ca7d2df4d7c9,
+ 0xc6ede63fa05d3143,0x91503d1c79720dbb,
+ 0xf8a95fcf88747d94,0x75a44c6397ce912a,
+ 0x9b69dbe1b548ce7c,0xc986afbe3ee11aba,
+ 0xc24452da229b021b,0xfbe85badce996168,
+ 0xf2d56790ab41c2a2,0xfae27299423fb9c3,
+ 0x97c560ba6b0919a5,0xdccd879fc967d41a,
+ 0xbdb6b8e905cb600f,0x5400e987bbc1c920,
+ 0xed246723473e3813,0x290123e9aab23b68,
+ 0x9436c0760c86e30b,0xf9a0b6720aaf6521,
+ 0xb94470938fa89bce,0xf808e40e8d5b3e69,
+ 0xe7958cb87392c2c2,0xb60b1d1230b20e04,
+ 0x90bd77f3483bb9b9,0xb1c6f22b5e6f48c2,
+ 0xb4ecd5f01a4aa828,0x1e38aeb6360b1af3,
+ 0xe2280b6c20dd5232,0x25c6da63c38de1b0,
+ 0x8d590723948a535f,0x579c487e5a38ad0e,
+ 0xb0af48ec79ace837,0x2d835a9df0c6d851,
+ 0xdcdb1b2798182244,0xf8e431456cf88e65,
+ 0x8a08f0f8bf0f156b,0x1b8e9ecb641b58ff,
+ 0xac8b2d36eed2dac5,0xe272467e3d222f3f,
+ 0xd7adf884aa879177,0x5b0ed81dcc6abb0f,
+ 0x86ccbb52ea94baea,0x98e947129fc2b4e9,
+ 0xa87fea27a539e9a5,0x3f2398d747b36224,
+ 0xd29fe4b18e88640e,0x8eec7f0d19a03aad,
+ 0x83a3eeeef9153e89,0x1953cf68300424ac,
+ 0xa48ceaaab75a8e2b,0x5fa8c3423c052dd7,
+ 0xcdb02555653131b6,0x3792f412cb06794d,
+ 0x808e17555f3ebf11,0xe2bbd88bbee40bd0,
+ 0xa0b19d2ab70e6ed6,0x5b6aceaeae9d0ec4,
+ 0xc8de047564d20a8b,0xf245825a5a445275,
+ 0xfb158592be068d2e,0xeed6e2f0f0d56712,
+ 0x9ced737bb6c4183d,0x55464dd69685606b,
+ 0xc428d05aa4751e4c,0xaa97e14c3c26b886,
+ 0xf53304714d9265df,0xd53dd99f4b3066a8,
+ 0x993fe2c6d07b7fab,0xe546a8038efe4029,
+ 0xbf8fdb78849a5f96,0xde98520472bdd033,
+ 0xef73d256a5c0f77c,0x963e66858f6d4440,
+ 0x95a8637627989aad,0xdde7001379a44aa8,
+ 0xbb127c53b17ec159,0x5560c018580d5d52,
+ 0xe9d71b689dde71af,0xaab8f01e6e10b4a6,
+ 0x9226712162ab070d,0xcab3961304ca70e8,
+ 0xb6b00d69bb55c8d1,0x3d607b97c5fd0d22,
+ 0xe45c10c42a2b3b05,0x8cb89a7db77c506a,
+ 0x8eb98a7a9a5b04e3,0x77f3608e92adb242,
+ 0xb267ed1940f1c61c,0x55f038b237591ed3,
+ 0xdf01e85f912e37a3,0x6b6c46dec52f6688,
+ 0x8b61313bbabce2c6,0x2323ac4b3b3da015,
+ 0xae397d8aa96c1b77,0xabec975e0a0d081a,
+ 0xd9c7dced53c72255,0x96e7bd358c904a21,
+ 0x881cea14545c7575,0x7e50d64177da2e54,
+ 0xaa242499697392d2,0xdde50bd1d5d0b9e9,
+ 0xd4ad2dbfc3d07787,0x955e4ec64b44e864,
+ 0x84ec3c97da624ab4,0xbd5af13bef0b113e,
+ 0xa6274bbdd0fadd61,0xecb1ad8aeacdd58e,
+ 0xcfb11ead453994ba,0x67de18eda5814af2,
+ 0x81ceb32c4b43fcf4,0x80eacf948770ced7,
+ 0xa2425ff75e14fc31,0xa1258379a94d028d,
+ 0xcad2f7f5359a3b3e,0x96ee45813a04330,
+ 0xfd87b5f28300ca0d,0x8bca9d6e188853fc,
+ 0x9e74d1b791e07e48,0x775ea264cf55347e,
+ 0xc612062576589dda,0x95364afe032a819e,
+ 0xf79687aed3eec551,0x3a83ddbd83f52205,
+ 0x9abe14cd44753b52,0xc4926a9672793543,
+ 0xc16d9a0095928a27,0x75b7053c0f178294,
+ 0xf1c90080baf72cb1,0x5324c68b12dd6339,
+ 0x971da05074da7bee,0xd3f6fc16ebca5e04,
+ 0xbce5086492111aea,0x88f4bb1ca6bcf585,
+ 0xec1e4a7db69561a5,0x2b31e9e3d06c32e6,
+ 0x9392ee8e921d5d07,0x3aff322e62439fd0,
+ 0xb877aa3236a4b449,0x9befeb9fad487c3,
+ 0xe69594bec44de15b,0x4c2ebe687989a9b4,
+ 0x901d7cf73ab0acd9,0xf9d37014bf60a11,
+ 0xb424dc35095cd80f,0x538484c19ef38c95,
+ 0xe12e13424bb40e13,0x2865a5f206b06fba,
+ 0x8cbccc096f5088cb,0xf93f87b7442e45d4,
+ 0xafebff0bcb24aafe,0xf78f69a51539d749,
+ 0xdbe6fecebdedd5be,0xb573440e5a884d1c,
+ 0x89705f4136b4a597,0x31680a88f8953031,
+ 0xabcc77118461cefc,0xfdc20d2b36ba7c3e,
+ 0xd6bf94d5e57a42bc,0x3d32907604691b4d,
+ 0x8637bd05af6c69b5,0xa63f9a49c2c1b110,
+ 0xa7c5ac471b478423,0xfcf80dc33721d54,
+ 0xd1b71758e219652b,0xd3c36113404ea4a9,
+ 0x83126e978d4fdf3b,0x645a1cac083126ea,
+ 0xa3d70a3d70a3d70a,0x3d70a3d70a3d70a4,
+ 0xcccccccccccccccc,0xcccccccccccccccd,
+ 0x8000000000000000,0x0,
+ 0xa000000000000000,0x0,
+ 0xc800000000000000,0x0,
+ 0xfa00000000000000,0x0,
+ 0x9c40000000000000,0x0,
+ 0xc350000000000000,0x0,
+ 0xf424000000000000,0x0,
+ 0x9896800000000000,0x0,
+ 0xbebc200000000000,0x0,
+ 0xee6b280000000000,0x0,
+ 0x9502f90000000000,0x0,
+ 0xba43b74000000000,0x0,
+ 0xe8d4a51000000000,0x0,
+ 0x9184e72a00000000,0x0,
+ 0xb5e620f480000000,0x0,
+ 0xe35fa931a0000000,0x0,
+ 0x8e1bc9bf04000000,0x0,
+ 0xb1a2bc2ec5000000,0x0,
+ 0xde0b6b3a76400000,0x0,
+ 0x8ac7230489e80000,0x0,
+ 0xad78ebc5ac620000,0x0,
+ 0xd8d726b7177a8000,0x0,
+ 0x878678326eac9000,0x0,
+ 0xa968163f0a57b400,0x0,
+ 0xd3c21bcecceda100,0x0,
+ 0x84595161401484a0,0x0,
+ 0xa56fa5b99019a5c8,0x0,
+ 0xcecb8f27f4200f3a,0x0,
+ 0x813f3978f8940984,0x4000000000000000,
+ 0xa18f07d736b90be5,0x5000000000000000,
+ 0xc9f2c9cd04674ede,0xa400000000000000,
+ 0xfc6f7c4045812296,0x4d00000000000000,
+ 0x9dc5ada82b70b59d,0xf020000000000000,
+ 0xc5371912364ce305,0x6c28000000000000,
+ 0xf684df56c3e01bc6,0xc732000000000000,
+ 0x9a130b963a6c115c,0x3c7f400000000000,
+ 0xc097ce7bc90715b3,0x4b9f100000000000,
+ 0xf0bdc21abb48db20,0x1e86d40000000000,
+ 0x96769950b50d88f4,0x1314448000000000,
+ 0xbc143fa4e250eb31,0x17d955a000000000,
+ 0xeb194f8e1ae525fd,0x5dcfab0800000000,
+ 0x92efd1b8d0cf37be,0x5aa1cae500000000,
+ 0xb7abc627050305ad,0xf14a3d9e40000000,
+ 0xe596b7b0c643c719,0x6d9ccd05d0000000,
+ 0x8f7e32ce7bea5c6f,0xe4820023a2000000,
+ 0xb35dbf821ae4f38b,0xdda2802c8a800000,
+ 0xe0352f62a19e306e,0xd50b2037ad200000,
+ 0x8c213d9da502de45,0x4526f422cc340000,
+ 0xaf298d050e4395d6,0x9670b12b7f410000,
+ 0xdaf3f04651d47b4c,0x3c0cdd765f114000,
+ 0x88d8762bf324cd0f,0xa5880a69fb6ac800,
+ 0xab0e93b6efee0053,0x8eea0d047a457a00,
+ 0xd5d238a4abe98068,0x72a4904598d6d880,
+ 0x85a36366eb71f041,0x47a6da2b7f864750,
+ 0xa70c3c40a64e6c51,0x999090b65f67d924,
+ 0xd0cf4b50cfe20765,0xfff4b4e3f741cf6d,
+ 0x82818f1281ed449f,0xbff8f10e7a8921a4,
+ 0xa321f2d7226895c7,0xaff72d52192b6a0d,
+ 0xcbea6f8ceb02bb39,0x9bf4f8a69f764490,
+ 0xfee50b7025c36a08,0x2f236d04753d5b4,
+ 0x9f4f2726179a2245,0x1d762422c946590,
+ 0xc722f0ef9d80aad6,0x424d3ad2b7b97ef5,
+ 0xf8ebad2b84e0d58b,0xd2e0898765a7deb2,
+ 0x9b934c3b330c8577,0x63cc55f49f88eb2f,
+ 0xc2781f49ffcfa6d5,0x3cbf6b71c76b25fb,
+ 0xf316271c7fc3908a,0x8bef464e3945ef7a,
+ 0x97edd871cfda3a56,0x97758bf0e3cbb5ac,
+ 0xbde94e8e43d0c8ec,0x3d52eeed1cbea317,
+ 0xed63a231d4c4fb27,0x4ca7aaa863ee4bdd,
+ 0x945e455f24fb1cf8,0x8fe8caa93e74ef6a,
+ 0xb975d6b6ee39e436,0xb3e2fd538e122b44,
+ 0xe7d34c64a9c85d44,0x60dbbca87196b616,
+ 0x90e40fbeea1d3a4a,0xbc8955e946fe31cd,
+ 0xb51d13aea4a488dd,0x6babab6398bdbe41,
+ 0xe264589a4dcdab14,0xc696963c7eed2dd1,
+ 0x8d7eb76070a08aec,0xfc1e1de5cf543ca2,
+ 0xb0de65388cc8ada8,0x3b25a55f43294bcb,
+ 0xdd15fe86affad912,0x49ef0eb713f39ebe,
+ 0x8a2dbf142dfcc7ab,0x6e3569326c784337,
+ 0xacb92ed9397bf996,0x49c2c37f07965404,
+ 0xd7e77a8f87daf7fb,0xdc33745ec97be906,
+ 0x86f0ac99b4e8dafd,0x69a028bb3ded71a3,
+ 0xa8acd7c0222311bc,0xc40832ea0d68ce0c,
+ 0xd2d80db02aabd62b,0xf50a3fa490c30190,
+ 0x83c7088e1aab65db,0x792667c6da79e0fa,
+ 0xa4b8cab1a1563f52,0x577001b891185938,
+ 0xcde6fd5e09abcf26,0xed4c0226b55e6f86,
+ 0x80b05e5ac60b6178,0x544f8158315b05b4,
+ 0xa0dc75f1778e39d6,0x696361ae3db1c721,
+ 0xc913936dd571c84c,0x3bc3a19cd1e38e9,
+ 0xfb5878494ace3a5f,0x4ab48a04065c723,
+ 0x9d174b2dcec0e47b,0x62eb0d64283f9c76,
+ 0xc45d1df942711d9a,0x3ba5d0bd324f8394,
+ 0xf5746577930d6500,0xca8f44ec7ee36479,
+ 0x9968bf6abbe85f20,0x7e998b13cf4e1ecb,
+ 0xbfc2ef456ae276e8,0x9e3fedd8c321a67e,
+ 0xefb3ab16c59b14a2,0xc5cfe94ef3ea101e,
+ 0x95d04aee3b80ece5,0xbba1f1d158724a12,
+ 0xbb445da9ca61281f,0x2a8a6e45ae8edc97,
+ 0xea1575143cf97226,0xf52d09d71a3293bd,
+ 0x924d692ca61be758,0x593c2626705f9c56,
+ 0xb6e0c377cfa2e12e,0x6f8b2fb00c77836c,
+ 0xe498f455c38b997a,0xb6dfb9c0f956447,
+ 0x8edf98b59a373fec,0x4724bd4189bd5eac,
+ 0xb2977ee300c50fe7,0x58edec91ec2cb657,
+ 0xdf3d5e9bc0f653e1,0x2f2967b66737e3ed,
+ 0x8b865b215899f46c,0xbd79e0d20082ee74,
+ 0xae67f1e9aec07187,0xecd8590680a3aa11,
+ 0xda01ee641a708de9,0xe80e6f4820cc9495,
+ 0x884134fe908658b2,0x3109058d147fdcdd,
+ 0xaa51823e34a7eede,0xbd4b46f0599fd415,
+ 0xd4e5e2cdc1d1ea96,0x6c9e18ac7007c91a,
+ 0x850fadc09923329e,0x3e2cf6bc604ddb0,
+ 0xa6539930bf6bff45,0x84db8346b786151c,
+ 0xcfe87f7cef46ff16,0xe612641865679a63,
+ 0x81f14fae158c5f6e,0x4fcb7e8f3f60c07e,
+ 0xa26da3999aef7749,0xe3be5e330f38f09d,
+ 0xcb090c8001ab551c,0x5cadf5bfd3072cc5,
+ 0xfdcb4fa002162a63,0x73d9732fc7c8f7f6,
+ 0x9e9f11c4014dda7e,0x2867e7fddcdd9afa,
+ 0xc646d63501a1511d,0xb281e1fd541501b8,
+ 0xf7d88bc24209a565,0x1f225a7ca91a4226,
+ 0x9ae757596946075f,0x3375788de9b06958,
+ 0xc1a12d2fc3978937,0x52d6b1641c83ae,
+ 0xf209787bb47d6b84,0xc0678c5dbd23a49a,
+ 0x9745eb4d50ce6332,0xf840b7ba963646e0,
+ 0xbd176620a501fbff,0xb650e5a93bc3d898,
+ 0xec5d3fa8ce427aff,0xa3e51f138ab4cebe,
+ 0x93ba47c980e98cdf,0xc66f336c36b10137,
+ 0xb8a8d9bbe123f017,0xb80b0047445d4184,
+ 0xe6d3102ad96cec1d,0xa60dc059157491e5,
+ 0x9043ea1ac7e41392,0x87c89837ad68db2f,
+ 0xb454e4a179dd1877,0x29babe4598c311fb,
+ 0xe16a1dc9d8545e94,0xf4296dd6fef3d67a,
+ 0x8ce2529e2734bb1d,0x1899e4a65f58660c,
+ 0xb01ae745b101e9e4,0x5ec05dcff72e7f8f,
+ 0xdc21a1171d42645d,0x76707543f4fa1f73,
+ 0x899504ae72497eba,0x6a06494a791c53a8,
+ 0xabfa45da0edbde69,0x487db9d17636892,
+ 0xd6f8d7509292d603,0x45a9d2845d3c42b6,
+ 0x865b86925b9bc5c2,0xb8a2392ba45a9b2,
+ 0xa7f26836f282b732,0x8e6cac7768d7141e,
+ 0xd1ef0244af2364ff,0x3207d795430cd926,
+ 0x8335616aed761f1f,0x7f44e6bd49e807b8,
+ 0xa402b9c5a8d3a6e7,0x5f16206c9c6209a6,
+ 0xcd036837130890a1,0x36dba887c37a8c0f,
+ 0x802221226be55a64,0xc2494954da2c9789,
+ 0xa02aa96b06deb0fd,0xf2db9baa10b7bd6c,
+ 0xc83553c5c8965d3d,0x6f92829494e5acc7,
+ 0xfa42a8b73abbf48c,0xcb772339ba1f17f9,
+ 0x9c69a97284b578d7,0xff2a760414536efb,
+ 0xc38413cf25e2d70d,0xfef5138519684aba,
+ 0xf46518c2ef5b8cd1,0x7eb258665fc25d69,
+ 0x98bf2f79d5993802,0xef2f773ffbd97a61,
+ 0xbeeefb584aff8603,0xaafb550ffacfd8fa,
+ 0xeeaaba2e5dbf6784,0x95ba2a53f983cf38,
+ 0x952ab45cfa97a0b2,0xdd945a747bf26183,
+ 0xba756174393d88df,0x94f971119aeef9e4,
+ 0xe912b9d1478ceb17,0x7a37cd5601aab85d,
+ 0x91abb422ccb812ee,0xac62e055c10ab33a,
+ 0xb616a12b7fe617aa,0x577b986b314d6009,
+ 0xe39c49765fdf9d94,0xed5a7e85fda0b80b,
+ 0x8e41ade9fbebc27d,0x14588f13be847307,
+ 0xb1d219647ae6b31c,0x596eb2d8ae258fc8,
+ 0xde469fbd99a05fe3,0x6fca5f8ed9aef3bb,
+ 0x8aec23d680043bee,0x25de7bb9480d5854,
+ 0xada72ccc20054ae9,0xaf561aa79a10ae6a,
+ 0xd910f7ff28069da4,0x1b2ba1518094da04,
+ 0x87aa9aff79042286,0x90fb44d2f05d0842,
+ 0xa99541bf57452b28,0x353a1607ac744a53,
+ 0xd3fa922f2d1675f2,0x42889b8997915ce8,
+ 0x847c9b5d7c2e09b7,0x69956135febada11,
+ 0xa59bc234db398c25,0x43fab9837e699095,
+ 0xcf02b2c21207ef2e,0x94f967e45e03f4bb,
+ 0x8161afb94b44f57d,0x1d1be0eebac278f5,
+ 0xa1ba1ba79e1632dc,0x6462d92a69731732,
+ 0xca28a291859bbf93,0x7d7b8f7503cfdcfe,
+ 0xfcb2cb35e702af78,0x5cda735244c3d43e,
+ 0x9defbf01b061adab,0x3a0888136afa64a7,
+ 0xc56baec21c7a1916,0x88aaa1845b8fdd0,
+ 0xf6c69a72a3989f5b,0x8aad549e57273d45,
+ 0x9a3c2087a63f6399,0x36ac54e2f678864b,
+ 0xc0cb28a98fcf3c7f,0x84576a1bb416a7dd,
+ 0xf0fdf2d3f3c30b9f,0x656d44a2a11c51d5,
+ 0x969eb7c47859e743,0x9f644ae5a4b1b325,
+ 0xbc4665b596706114,0x873d5d9f0dde1fee,
+ 0xeb57ff22fc0c7959,0xa90cb506d155a7ea,
+ 0x9316ff75dd87cbd8,0x9a7f12442d588f2,
+ 0xb7dcbf5354e9bece,0xc11ed6d538aeb2f,
+ 0xe5d3ef282a242e81,0x8f1668c8a86da5fa,
+ 0x8fa475791a569d10,0xf96e017d694487bc,
+ 0xb38d92d760ec4455,0x37c981dcc395a9ac,
+ 0xe070f78d3927556a,0x85bbe253f47b1417,
+ 0x8c469ab843b89562,0x93956d7478ccec8e,
+ 0xaf58416654a6babb,0x387ac8d1970027b2,
+ 0xdb2e51bfe9d0696a,0x6997b05fcc0319e,
+ 0x88fcf317f22241e2,0x441fece3bdf81f03,
+ 0xab3c2fddeeaad25a,0xd527e81cad7626c3,
+ 0xd60b3bd56a5586f1,0x8a71e223d8d3b074,
+ 0x85c7056562757456,0xf6872d5667844e49,
+ 0xa738c6bebb12d16c,0xb428f8ac016561db,
+ 0xd106f86e69d785c7,0xe13336d701beba52,
+ 0x82a45b450226b39c,0xecc0024661173473,
+ 0xa34d721642b06084,0x27f002d7f95d0190,
+ 0xcc20ce9bd35c78a5,0x31ec038df7b441f4,
+ 0xff290242c83396ce,0x7e67047175a15271,
+ 0x9f79a169bd203e41,0xf0062c6e984d386,
+ 0xc75809c42c684dd1,0x52c07b78a3e60868,
+ 0xf92e0c3537826145,0xa7709a56ccdf8a82,
+ 0x9bbcc7a142b17ccb,0x88a66076400bb691,
+ 0xc2abf989935ddbfe,0x6acff893d00ea435,
+ 0xf356f7ebf83552fe,0x583f6b8c4124d43,
+ 0x98165af37b2153de,0xc3727a337a8b704a,
+ 0xbe1bf1b059e9a8d6,0x744f18c0592e4c5c,
+ 0xeda2ee1c7064130c,0x1162def06f79df73,
+ 0x9485d4d1c63e8be7,0x8addcb5645ac2ba8,
+ 0xb9a74a0637ce2ee1,0x6d953e2bd7173692,
+ 0xe8111c87c5c1ba99,0xc8fa8db6ccdd0437,
+ 0x910ab1d4db9914a0,0x1d9c9892400a22a2,
+ 0xb54d5e4a127f59c8,0x2503beb6d00cab4b,
+ 0xe2a0b5dc971f303a,0x2e44ae64840fd61d,
+ 0x8da471a9de737e24,0x5ceaecfed289e5d2,
+ 0xb10d8e1456105dad,0x7425a83e872c5f47,
+ 0xdd50f1996b947518,0xd12f124e28f77719,
+ 0x8a5296ffe33cc92f,0x82bd6b70d99aaa6f,
+ 0xace73cbfdc0bfb7b,0x636cc64d1001550b,
+ 0xd8210befd30efa5a,0x3c47f7e05401aa4e,
+ 0x8714a775e3e95c78,0x65acfaec34810a71,
+ 0xa8d9d1535ce3b396,0x7f1839a741a14d0d,
+ 0xd31045a8341ca07c,0x1ede48111209a050,
+ 0x83ea2b892091e44d,0x934aed0aab460432,
+ 0xa4e4b66b68b65d60,0xf81da84d5617853f,
+ 0xce1de40642e3f4b9,0x36251260ab9d668e,
+ 0x80d2ae83e9ce78f3,0xc1d72b7c6b426019,
+ 0xa1075a24e4421730,0xb24cf65b8612f81f,
+ 0xc94930ae1d529cfc,0xdee033f26797b627,
+ 0xfb9b7cd9a4a7443c,0x169840ef017da3b1,
+ 0x9d412e0806e88aa5,0x8e1f289560ee864e,
+ 0xc491798a08a2ad4e,0xf1a6f2bab92a27e2,
+ 0xf5b5d7ec8acb58a2,0xae10af696774b1db,
+ 0x9991a6f3d6bf1765,0xacca6da1e0a8ef29,
+ 0xbff610b0cc6edd3f,0x17fd090a58d32af3,
+ 0xeff394dcff8a948e,0xddfc4b4cef07f5b0,
+ 0x95f83d0a1fb69cd9,0x4abdaf101564f98e,
+ 0xbb764c4ca7a4440f,0x9d6d1ad41abe37f1,
+ 0xea53df5fd18d5513,0x84c86189216dc5ed,
+ 0x92746b9be2f8552c,0x32fd3cf5b4e49bb4,
+ 0xb7118682dbb66a77,0x3fbc8c33221dc2a1,
+ 0xe4d5e82392a40515,0xfabaf3feaa5334a,
+ 0x8f05b1163ba6832d,0x29cb4d87f2a7400e,
+ 0xb2c71d5bca9023f8,0x743e20e9ef511012,
+ 0xdf78e4b2bd342cf6,0x914da9246b255416,
+ 0x8bab8eefb6409c1a,0x1ad089b6c2f7548e,
+ 0xae9672aba3d0c320,0xa184ac2473b529b1,
+ 0xda3c0f568cc4f3e8,0xc9e5d72d90a2741e,
+ 0x8865899617fb1871,0x7e2fa67c7a658892,
+ 0xaa7eebfb9df9de8d,0xddbb901b98feeab7,
+ 0xd51ea6fa85785631,0x552a74227f3ea565,
+ 0x8533285c936b35de,0xd53a88958f87275f,
+ 0xa67ff273b8460356,0x8a892abaf368f137,
+ 0xd01fef10a657842c,0x2d2b7569b0432d85,
+ 0x8213f56a67f6b29b,0x9c3b29620e29fc73,
+ 0xa298f2c501f45f42,0x8349f3ba91b47b8f,
+ 0xcb3f2f7642717713,0x241c70a936219a73,
+ 0xfe0efb53d30dd4d7,0xed238cd383aa0110,
+ 0x9ec95d1463e8a506,0xf4363804324a40aa,
+ 0xc67bb4597ce2ce48,0xb143c6053edcd0d5,
+ 0xf81aa16fdc1b81da,0xdd94b7868e94050a,
+ 0x9b10a4e5e9913128,0xca7cf2b4191c8326,
+ 0xc1d4ce1f63f57d72,0xfd1c2f611f63a3f0,
+ 0xf24a01a73cf2dccf,0xbc633b39673c8cec,
+ 0x976e41088617ca01,0xd5be0503e085d813,
+ 0xbd49d14aa79dbc82,0x4b2d8644d8a74e18,
+ 0xec9c459d51852ba2,0xddf8e7d60ed1219e,
+ 0x93e1ab8252f33b45,0xcabb90e5c942b503,
+ 0xb8da1662e7b00a17,0x3d6a751f3b936243,
+ 0xe7109bfba19c0c9d,0xcc512670a783ad4,
+ 0x906a617d450187e2,0x27fb2b80668b24c5,
+ 0xb484f9dc9641e9da,0xb1f9f660802dedf6,
+ 0xe1a63853bbd26451,0x5e7873f8a0396973,
+ 0x8d07e33455637eb2,0xdb0b487b6423e1e8,
+ 0xb049dc016abc5e5f,0x91ce1a9a3d2cda62,
+ 0xdc5c5301c56b75f7,0x7641a140cc7810fb,
+ 0x89b9b3e11b6329ba,0xa9e904c87fcb0a9d,
+ 0xac2820d9623bf429,0x546345fa9fbdcd44,
+ 0xd732290fbacaf133,0xa97c177947ad4095,
+ 0x867f59a9d4bed6c0,0x49ed8eabcccc485d,
+ 0xa81f301449ee8c70,0x5c68f256bfff5a74,
+ 0xd226fc195c6a2f8c,0x73832eec6fff3111,
+ 0x83585d8fd9c25db7,0xc831fd53c5ff7eab,
+ 0xa42e74f3d032f525,0xba3e7ca8b77f5e55,
+ 0xcd3a1230c43fb26f,0x28ce1bd2e55f35eb,
+ 0x80444b5e7aa7cf85,0x7980d163cf5b81b3,
+ 0xa0555e361951c366,0xd7e105bcc332621f,
+ 0xc86ab5c39fa63440,0x8dd9472bf3fefaa7,
+ 0xfa856334878fc150,0xb14f98f6f0feb951,
+ 0x9c935e00d4b9d8d2,0x6ed1bf9a569f33d3,
+ 0xc3b8358109e84f07,0xa862f80ec4700c8,
+ 0xf4a642e14c6262c8,0xcd27bb612758c0fa,
+ 0x98e7e9cccfbd7dbd,0x8038d51cb897789c,
+ 0xbf21e44003acdd2c,0xe0470a63e6bd56c3,
+ 0xeeea5d5004981478,0x1858ccfce06cac74,
+ 0x95527a5202df0ccb,0xf37801e0c43ebc8,
+ 0xbaa718e68396cffd,0xd30560258f54e6ba,
+ 0xe950df20247c83fd,0x47c6b82ef32a2069,
+ 0x91d28b7416cdd27e,0x4cdc331d57fa5441,
+ 0xb6472e511c81471d,0xe0133fe4adf8e952,
+ 0xe3d8f9e563a198e5,0x58180fddd97723a6,
+ 0x8e679c2f5e44ff8f,0x570f09eaa7ea7648,};
+using powers = powers_template<>;
+
+}
+
+#endif
+
+#ifndef FASTFLOAT_DECIMAL_TO_BINARY_H
+#define FASTFLOAT_DECIMAL_TO_BINARY_H
+
+#include <cfloat>
+#include <cinttypes>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+
+namespace fast_float {
+
+// This will compute or rather approximate w * 5**q and return a pair of 64-bit words approximating
+// the result, with the "high" part corresponding to the most significant bits and the
+// low part corresponding to the least significant bits.
+//
+template <int bit_precision>
+fastfloat_really_inline
+value128 compute_product_approximation(int64_t q, uint64_t w) {
+ const int index = 2 * int(q - powers::smallest_power_of_five);
+ // For small values of q, e.g., q in [0,27], the answer is always exact because
+ // The line value128 firstproduct = full_multiplication(w, power_of_five_128[index]);
+ // gives the exact answer.
+ value128 firstproduct = full_multiplication(w, powers::power_of_five_128[index]);
+ static_assert((bit_precision >= 0) && (bit_precision <= 64), " precision should be in (0,64]");
+ constexpr uint64_t precision_mask = (bit_precision < 64) ?
+ (uint64_t(0xFFFFFFFFFFFFFFFF) >> bit_precision)
+ : uint64_t(0xFFFFFFFFFFFFFFFF);
+ if((firstproduct.high & precision_mask) == precision_mask) { // could further guard with (lower + w < lower)
+ // regarding the second product, we only need secondproduct.high, but our expectation is that the compiler will optimize this extra work away if needed.
+ value128 secondproduct = full_multiplication(w, powers::power_of_five_128[index + 1]);
+ firstproduct.low += secondproduct.high;
+ if(secondproduct.high > firstproduct.low) {
+ firstproduct.high++;
+ }
+ }
+ return firstproduct;
+}
+
+namespace detail {
+/**
+ * For q in (0,350), we have that
+ * f = (((152170 + 65536) * q ) >> 16);
+ * is equal to
+ * floor(p) + q
+ * where
+ * p = log(5**q)/log(2) = q * log(5)/log(2)
+ *
+ * For negative values of q in (-400,0), we have that
+ * f = (((152170 + 65536) * q ) >> 16);
+ * is equal to
+ * -ceil(p) + q
+ * where
+ * p = log(5**-q)/log(2) = -q * log(5)/log(2)
+ */
+ constexpr fastfloat_really_inline int32_t power(int32_t q) noexcept {
+ return (((152170 + 65536) * q) >> 16) + 63;
+ }
+} // namespace detail
+
+// create an adjusted mantissa, biased by the invalid power2
+// for significant digits already multiplied by 10 ** q.
+template <typename binary>
+fastfloat_really_inline
+adjusted_mantissa compute_error_scaled(int64_t q, uint64_t w, int lz) noexcept {
+ int hilz = int(w >> 63) ^ 1;
+ adjusted_mantissa answer;
+ answer.mantissa = w << hilz;
+ int bias = binary::mantissa_explicit_bits() - binary::minimum_exponent();
+ answer.power2 = int32_t(detail::power(int32_t(q)) + bias - hilz - lz - 62 + invalid_am_bias);
+ return answer;
+}
+
+// w * 10 ** q, without rounding the representation up.
+// the power2 in the exponent will be adjusted by invalid_am_bias.
+template <typename binary>
+fastfloat_really_inline
+adjusted_mantissa compute_error(int64_t q, uint64_t w) noexcept {
+ int lz = leading_zeroes(w);
+ w <<= lz;
+ value128 product = compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
+ return compute_error_scaled<binary>(q, product.high, lz);
+}
+
+// w * 10 ** q
+// The returned value should be a valid ieee64 number that simply need to be packed.
+// However, in some very rare cases, the computation will fail. In such cases, we
+// return an adjusted_mantissa with a negative power of 2: the caller should recompute
+// in such cases.
+template <typename binary>
+fastfloat_really_inline
+adjusted_mantissa compute_float(int64_t q, uint64_t w) noexcept {
+ adjusted_mantissa answer;
+ if ((w == 0) || (q < binary::smallest_power_of_ten())) {
+ answer.power2 = 0;
+ answer.mantissa = 0;
+ // result should be zero
+ return answer;
+ }
+ if (q > binary::largest_power_of_ten()) {
+ // we want to get infinity:
+ answer.power2 = binary::infinite_power();
+ answer.mantissa = 0;
+ return answer;
+ }
+ // At this point in time q is in [powers::smallest_power_of_five, powers::largest_power_of_five].
+
+ // We want the most significant bit of i to be 1. Shift if needed.
+ int lz = leading_zeroes(w);
+ w <<= lz;
+
+ // The required precision is binary::mantissa_explicit_bits() + 3 because
+ // 1. We need the implicit bit
+ // 2. We need an extra bit for rounding purposes
+ // 3. We might lose a bit due to the "upperbit" routine (result too small, requiring a shift)
+
+ value128 product = compute_product_approximation<binary::mantissa_explicit_bits() + 3>(q, w);
+ if(product.low == 0xFFFFFFFFFFFFFFFF) { // could guard it further
+ // In some very rare cases, this could happen, in which case we might need a more accurate
+ // computation that what we can provide cheaply. This is very, very unlikely.
+ //
+ const bool inside_safe_exponent = (q >= -27) && (q <= 55); // always good because 5**q <2**128 when q>=0,
+ // and otherwise, for q<0, we have 5**-q<2**64 and the 128-bit reciprocal allows for exact computation.
+ if(!inside_safe_exponent) {
+ return compute_error_scaled<binary>(q, product.high, lz);
+ }
+ }
+ // The "compute_product_approximation" function can be slightly slower than a branchless approach:
+ // value128 product = compute_product(q, w);
+ // but in practice, we can win big with the compute_product_approximation if its additional branch
+ // is easily predicted. Which is best is data specific.
+ int upperbit = int(product.high >> 63);
+
+ answer.mantissa = product.high >> (upperbit + 64 - binary::mantissa_explicit_bits() - 3);
+
+ answer.power2 = int32_t(detail::power(int32_t(q)) + upperbit - lz - binary::minimum_exponent());
+ if (answer.power2 <= 0) { // we have a subnormal?
+ // Here have that answer.power2 <= 0 so -answer.power2 >= 0
+ if(-answer.power2 + 1 >= 64) { // if we have more than 64 bits below the minimum exponent, you have a zero for sure.
+ answer.power2 = 0;
+ answer.mantissa = 0;
+ // result should be zero
+ return answer;
+ }
+ // next line is safe because -answer.power2 + 1 < 64
+ answer.mantissa >>= -answer.power2 + 1;
+ // Thankfully, we can't have both "round-to-even" and subnormals because
+ // "round-to-even" only occurs for powers close to 0.
+ answer.mantissa += (answer.mantissa & 1); // round up
+ answer.mantissa >>= 1;
+ // There is a weird scenario where we don't have a subnormal but just.
+ // Suppose we start with 2.2250738585072013e-308, we end up
+ // with 0x3fffffffffffff x 2^-1023-53 which is technically subnormal
+ // whereas 0x40000000000000 x 2^-1023-53 is normal. Now, we need to round
+ // up 0x3fffffffffffff x 2^-1023-53 and once we do, we are no longer
+ // subnormal, but we can only know this after rounding.
+ // So we only declare a subnormal if we are smaller than the threshold.
+ answer.power2 = (answer.mantissa < (uint64_t(1) << binary::mantissa_explicit_bits())) ? 0 : 1;
+ return answer;
+ }
+
+ // usually, we round *up*, but if we fall right in between and and we have an
+ // even basis, we need to round down
+ // We are only concerned with the cases where 5**q fits in single 64-bit word.
+ if ((product.low <= 1) && (q >= binary::min_exponent_round_to_even()) && (q <= binary::max_exponent_round_to_even()) &&
+ ((answer.mantissa & 3) == 1) ) { // we may fall between two floats!
+ // To be in-between two floats we need that in doing
+ // answer.mantissa = product.high >> (upperbit + 64 - binary::mantissa_explicit_bits() - 3);
+ // ... we dropped out only zeroes. But if this happened, then we can go back!!!
+ if((answer.mantissa << (upperbit + 64 - binary::mantissa_explicit_bits() - 3)) == product.high) {
+ answer.mantissa &= ~uint64_t(1); // flip it so that we do not round up
+ }
+ }
+
+ answer.mantissa += (answer.mantissa & 1); // round up
+ answer.mantissa >>= 1;
+ if (answer.mantissa >= (uint64_t(2) << binary::mantissa_explicit_bits())) {
+ answer.mantissa = (uint64_t(1) << binary::mantissa_explicit_bits());
+ answer.power2++; // undo previous addition
+ }
+
+ answer.mantissa &= ~(uint64_t(1) << binary::mantissa_explicit_bits());
+ if (answer.power2 >= binary::infinite_power()) { // infinity
+ answer.power2 = binary::infinite_power();
+ answer.mantissa = 0;
+ }
+ return answer;
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_BIGINT_H
+#define FASTFLOAT_BIGINT_H
+
+#include <algorithm>
+#include <cstdint>
+#include <climits>
+#include <cstring>
+
+
+namespace fast_float {
+
+// the limb width: we want efficient multiplication of double the bits in
+// limb, or for 64-bit limbs, at least 64-bit multiplication where we can
+// extract the high and low parts efficiently. this is every 64-bit
+// architecture except for sparc, which emulates 128-bit multiplication.
+// we might have platforms where `CHAR_BIT` is not 8, so let's avoid
+// doing `8 * sizeof(limb)`.
+#if defined(FASTFLOAT_64BIT) && !defined(__sparc)
+#define FASTFLOAT_64BIT_LIMB
+typedef uint64_t limb;
+constexpr size_t limb_bits = 64;
+#else
+#define FASTFLOAT_32BIT_LIMB
+typedef uint32_t limb;
+constexpr size_t limb_bits = 32;
+#endif
+
+typedef span<limb> limb_span;
+
+// number of bits in a bigint. this needs to be at least the number
+// of bits required to store the largest bigint, which is
+// `log2(10**(digits + max_exp))`, or `log2(10**(767 + 342))`, or
+// ~3600 bits, so we round to 4000.
+constexpr size_t bigint_bits = 4000;
+constexpr size_t bigint_limbs = bigint_bits / limb_bits;
+
+// vector-like type that is allocated on the stack. the entire
+// buffer is pre-allocated, and only the length changes.
+template <uint16_t size>
+struct stackvec {
+ limb data[size];
+ // we never need more than 150 limbs
+ uint16_t length{0};
+
+ stackvec() = default;
+ stackvec(const stackvec &) = delete;
+ stackvec &operator=(const stackvec &) = delete;
+ stackvec(stackvec &&) = delete;
+ stackvec &operator=(stackvec &&other) = delete;
+
+ // create stack vector from existing limb span.
+ stackvec(limb_span s) {
+ FASTFLOAT_ASSERT(try_extend(s));
+ }
+
+ limb& operator[](size_t index) noexcept {
+ FASTFLOAT_DEBUG_ASSERT(index < length);
+ return data[index];
+ }
+ const limb& operator[](size_t index) const noexcept {
+ FASTFLOAT_DEBUG_ASSERT(index < length);
+ return data[index];
+ }
+ // index from the end of the container
+ const limb& rindex(size_t index) const noexcept {
+ FASTFLOAT_DEBUG_ASSERT(index < length);
+ size_t rindex = length - index - 1;
+ return data[rindex];
+ }
+
+ // set the length, without bounds checking.
+ void set_len(size_t len) noexcept {
+ length = uint16_t(len);
+ }
+ constexpr size_t len() const noexcept {
+ return length;
+ }
+ constexpr bool is_empty() const noexcept {
+ return length == 0;
+ }
+ constexpr size_t capacity() const noexcept {
+ return size;
+ }
+ // append item to vector, without bounds checking
+ void push_unchecked(limb value) noexcept {
+ data[length] = value;
+ length++;
+ }
+ // append item to vector, returning if item was added
+ bool try_push(limb value) noexcept {
+ if (len() < capacity()) {
+ push_unchecked(value);
+ return true;
+ } else {
+ return false;
+ }
+ }
+ // add items to the vector, from a span, without bounds checking
+ void extend_unchecked(limb_span s) noexcept {
+ limb* ptr = data + length;
+ ::memcpy((void*)ptr, (const void*)s.ptr, sizeof(limb) * s.len());
+ set_len(len() + s.len());
+ }
+ // try to add items to the vector, returning if items were added
+ bool try_extend(limb_span s) noexcept {
+ if (len() + s.len() <= capacity()) {
+ extend_unchecked(s);
+ return true;
+ } else {
+ return false;
+ }
+ }
+ // resize the vector, without bounds checking
+ // if the new size is longer than the vector, assign value to each
+ // appended item.
+ void resize_unchecked(size_t new_len, limb value) noexcept {
+ if (new_len > len()) {
+ size_t count = new_len - len();
+ limb* first = data + len();
+ limb* last = first + count;
+ ::std::fill(first, last, value);
+ set_len(new_len);
+ } else {
+ set_len(new_len);
+ }
+ }
+ // try to resize the vector, returning if the vector was resized.
+ bool try_resize(size_t new_len, limb value) noexcept {
+ if (new_len > capacity()) {
+ return false;
+ } else {
+ resize_unchecked(new_len, value);
+ return true;
+ }
+ }
+ // check if any limbs are non-zero after the given index.
+ // this needs to be done in reverse order, since the index
+ // is relative to the most significant limbs.
+ bool nonzero(size_t index) const noexcept {
+ while (index < len()) {
+ if (rindex(index) != 0) {
+ return true;
+ }
+ index++;
+ }
+ return false;
+ }
+ // normalize the big integer, so most-significant zero limbs are removed.
+ void normalize() noexcept {
+ while (len() > 0 && rindex(0) == 0) {
+ length--;
+ }
+ }
+};
+
+fastfloat_really_inline
+uint64_t empty_hi64(bool& truncated) noexcept {
+ truncated = false;
+ return 0;
+}
+
+fastfloat_really_inline
+uint64_t uint64_hi64(uint64_t r0, bool& truncated) noexcept {
+ truncated = false;
+ int shl = leading_zeroes(r0);
+ return r0 << shl;
+}
+
+fastfloat_really_inline
+uint64_t uint64_hi64(uint64_t r0, uint64_t r1, bool& truncated) noexcept {
+ int shl = leading_zeroes(r0);
+ if (shl == 0) {
+ truncated = r1 != 0;
+ return r0;
+ } else {
+ int shr = 64 - shl;
+ truncated = (r1 << shl) != 0;
+ return (r0 << shl) | (r1 >> shr);
+ }
+}
+
+fastfloat_really_inline
+uint64_t uint32_hi64(uint32_t r0, bool& truncated) noexcept {
+ return uint64_hi64(r0, truncated);
+}
+
+fastfloat_really_inline
+uint64_t uint32_hi64(uint32_t r0, uint32_t r1, bool& truncated) noexcept {
+ uint64_t x0 = r0;
+ uint64_t x1 = r1;
+ return uint64_hi64((x0 << 32) | x1, truncated);
+}
+
+fastfloat_really_inline
+uint64_t uint32_hi64(uint32_t r0, uint32_t r1, uint32_t r2, bool& truncated) noexcept {
+ uint64_t x0 = r0;
+ uint64_t x1 = r1;
+ uint64_t x2 = r2;
+ return uint64_hi64(x0, (x1 << 32) | x2, truncated);
+}
+
+// add two small integers, checking for overflow.
+// we want an efficient operation. for msvc, where
+// we don't have built-in intrinsics, this is still
+// pretty fast.
+fastfloat_really_inline
+limb scalar_add(limb x, limb y, bool& overflow) noexcept {
+ limb z;
+
+// gcc and clang
+#if defined(__has_builtin)
+ #if __has_builtin(__builtin_add_overflow)
+ overflow = __builtin_add_overflow(x, y, &z);
+ return z;
+ #endif
+#endif
+
+ // generic, this still optimizes correctly on MSVC.
+ z = x + y;
+ overflow = z < x;
+ return z;
+}
+
+// multiply two small integers, getting both the high and low bits.
+fastfloat_really_inline
+limb scalar_mul(limb x, limb y, limb& carry) noexcept {
+#ifdef FASTFLOAT_64BIT_LIMB
+ #if defined(__SIZEOF_INT128__)
+ // GCC and clang both define it as an extension.
+ __uint128_t z = __uint128_t(x) * __uint128_t(y) + __uint128_t(carry);
+ carry = limb(z >> limb_bits);
+ return limb(z);
+ #else
+ // fallback, no native 128-bit integer multiplication with carry.
+ // on msvc, this optimizes identically, somehow.
+ value128 z = full_multiplication(x, y);
+ bool overflow;
+ z.low = scalar_add(z.low, carry, overflow);
+ z.high += uint64_t(overflow); // cannot overflow
+ carry = z.high;
+ return z.low;
+ #endif
+#else
+ uint64_t z = uint64_t(x) * uint64_t(y) + uint64_t(carry);
+ carry = limb(z >> limb_bits);
+ return limb(z);
+#endif
+}
+
+// add scalar value to bigint starting from offset.
+// used in grade school multiplication
+template <uint16_t size>
+inline bool small_add_from(stackvec<size>& vec, limb y, size_t start) noexcept {
+ size_t index = start;
+ limb carry = y;
+ bool overflow;
+ while (carry != 0 && index < vec.len()) {
+ vec[index] = scalar_add(vec[index], carry, overflow);
+ carry = limb(overflow);
+ index += 1;
+ }
+ if (carry != 0) {
+ FASTFLOAT_TRY(vec.try_push(carry));
+ }
+ return true;
+}
+
+// add scalar value to bigint.
+template <uint16_t size>
+fastfloat_really_inline bool small_add(stackvec<size>& vec, limb y) noexcept {
+ return small_add_from(vec, y, 0);
+}
+
+// multiply bigint by scalar value.
+template <uint16_t size>
+inline bool small_mul(stackvec<size>& vec, limb y) noexcept {
+ limb carry = 0;
+ for (size_t index = 0; index < vec.len(); index++) {
+ vec[index] = scalar_mul(vec[index], y, carry);
+ }
+ if (carry != 0) {
+ FASTFLOAT_TRY(vec.try_push(carry));
+ }
+ return true;
+}
+
+// add bigint to bigint starting from index.
+// used in grade school multiplication
+template <uint16_t size>
+bool large_add_from(stackvec<size>& x, limb_span y, size_t start) noexcept {
+ // the effective x buffer is from `xstart..x.len()`, so exit early
+ // if we can't get that current range.
+ if (x.len() < start || y.len() > x.len() - start) {
+ FASTFLOAT_TRY(x.try_resize(y.len() + start, 0));
+ }
+
+ bool carry = false;
+ for (size_t index = 0; index < y.len(); index++) {
+ limb xi = x[index + start];
+ limb yi = y[index];
+ bool c1 = false;
+ bool c2 = false;
+ xi = scalar_add(xi, yi, c1);
+ if (carry) {
+ xi = scalar_add(xi, 1, c2);
+ }
+ x[index + start] = xi;
+ carry = c1 | c2;
+ }
+
+ // handle overflow
+ if (carry) {
+ FASTFLOAT_TRY(small_add_from(x, 1, y.len() + start));
+ }
+ return true;
+}
+
+// add bigint to bigint.
+template <uint16_t size>
+fastfloat_really_inline bool large_add_from(stackvec<size>& x, limb_span y) noexcept {
+ return large_add_from(x, y, 0);
+}
+
+// grade-school multiplication algorithm
+template <uint16_t size>
+bool long_mul(stackvec<size>& x, limb_span y) noexcept {
+ limb_span xs = limb_span(x.data, x.len());
+ stackvec<size> z(xs);
+ limb_span zs = limb_span(z.data, z.len());
+
+ if (y.len() != 0) {
+ limb y0 = y[0];
+ FASTFLOAT_TRY(small_mul(x, y0));
+ for (size_t index = 1; index < y.len(); index++) {
+ limb yi = y[index];
+ stackvec<size> zi;
+ if (yi != 0) {
+ // re-use the same buffer throughout
+ zi.set_len(0);
+ FASTFLOAT_TRY(zi.try_extend(zs));
+ FASTFLOAT_TRY(small_mul(zi, yi));
+ limb_span zis = limb_span(zi.data, zi.len());
+ FASTFLOAT_TRY(large_add_from(x, zis, index));
+ }
+ }
+ }
+
+ x.normalize();
+ return true;
+}
+
+// grade-school multiplication algorithm
+template <uint16_t size>
+bool large_mul(stackvec<size>& x, limb_span y) noexcept {
+ if (y.len() == 1) {
+ FASTFLOAT_TRY(small_mul(x, y[0]));
+ } else {
+ FASTFLOAT_TRY(long_mul(x, y));
+ }
+ return true;
+}
+
+// big integer type. implements a small subset of big integer
+// arithmetic, using simple algorithms since asymptotically
+// faster algorithms are slower for a small number of limbs.
+// all operations assume the big-integer is normalized.
+struct bigint {
+ // storage of the limbs, in little-endian order.
+ stackvec<bigint_limbs> vec;
+
+ bigint(): vec() {}
+ bigint(const bigint &) = delete;
+ bigint &operator=(const bigint &) = delete;
+ bigint(bigint &&) = delete;
+ bigint &operator=(bigint &&other) = delete;
+
+ bigint(uint64_t value): vec() {
+#ifdef FASTFLOAT_64BIT_LIMB
+ vec.push_unchecked(value);
+#else
+ vec.push_unchecked(uint32_t(value));
+ vec.push_unchecked(uint32_t(value >> 32));
+#endif
+ vec.normalize();
+ }
+
+ // get the high 64 bits from the vector, and if bits were truncated.
+ // this is to get the significant digits for the float.
+ uint64_t hi64(bool& truncated) const noexcept {
+#ifdef FASTFLOAT_64BIT_LIMB
+ if (vec.len() == 0) {
+ return empty_hi64(truncated);
+ } else if (vec.len() == 1) {
+ return uint64_hi64(vec.rindex(0), truncated);
+ } else {
+ uint64_t result = uint64_hi64(vec.rindex(0), vec.rindex(1), truncated);
+ truncated |= vec.nonzero(2);
+ return result;
+ }
+#else
+ if (vec.len() == 0) {
+ return empty_hi64(truncated);
+ } else if (vec.len() == 1) {
+ return uint32_hi64(vec.rindex(0), truncated);
+ } else if (vec.len() == 2) {
+ return uint32_hi64(vec.rindex(0), vec.rindex(1), truncated);
+ } else {
+ uint64_t result = uint32_hi64(vec.rindex(0), vec.rindex(1), vec.rindex(2), truncated);
+ truncated |= vec.nonzero(3);
+ return result;
+ }
+#endif
+ }
+
+ // compare two big integers, returning the large value.
+ // assumes both are normalized. if the return value is
+ // negative, other is larger, if the return value is
+ // positive, this is larger, otherwise they are equal.
+ // the limbs are stored in little-endian order, so we
+ // must compare the limbs in ever order.
+ int compare(const bigint& other) const noexcept {
+ if (vec.len() > other.vec.len()) {
+ return 1;
+ } else if (vec.len() < other.vec.len()) {
+ return -1;
+ } else {
+ for (size_t index = vec.len(); index > 0; index--) {
+ limb xi = vec[index - 1];
+ limb yi = other.vec[index - 1];
+ if (xi > yi) {
+ return 1;
+ } else if (xi < yi) {
+ return -1;
+ }
+ }
+ return 0;
+ }
+ }
+
+ // shift left each limb n bits, carrying over to the new limb
+ // returns true if we were able to shift all the digits.
+ bool shl_bits(size_t n) noexcept {
+ // Internally, for each item, we shift left by n, and add the previous
+ // right shifted limb-bits.
+ // For example, we transform (for u8) shifted left 2, to:
+ // b10100100 b01000010
+ // b10 b10010001 b00001000
+ FASTFLOAT_DEBUG_ASSERT(n != 0);
+ FASTFLOAT_DEBUG_ASSERT(n < sizeof(limb) * 8);
+
+ size_t shl = n;
+ size_t shr = limb_bits - shl;
+ limb prev = 0;
+ for (size_t index = 0; index < vec.len(); index++) {
+ limb xi = vec[index];
+ vec[index] = (xi << shl) | (prev >> shr);
+ prev = xi;
+ }
+
+ limb carry = prev >> shr;
+ if (carry != 0) {
+ return vec.try_push(carry);
+ }
+ return true;
+ }
+
+ // move the limbs left by `n` limbs.
+ bool shl_limbs(size_t n) noexcept {
+ FASTFLOAT_DEBUG_ASSERT(n != 0);
+ if (n + vec.len() > vec.capacity()) {
+ return false;
+ } else if (!vec.is_empty()) {
+ // move limbs
+ limb* dst = vec.data + n;
+ const limb* src = vec.data;
+ ::memmove(dst, src, sizeof(limb) * vec.len());
+ // fill in empty limbs
+ limb* first = vec.data;
+ limb* last = first + n;
+ ::std::fill(first, last, 0);
+ vec.set_len(n + vec.len());
+ return true;
+ } else {
+ return true;
+ }
+ }
+
+ // move the limbs left by `n` bits.
+ bool shl(size_t n) noexcept {
+ size_t rem = n % limb_bits;
+ size_t div = n / limb_bits;
+ if (rem != 0) {
+ FASTFLOAT_TRY(shl_bits(rem));
+ }
+ if (div != 0) {
+ FASTFLOAT_TRY(shl_limbs(div));
+ }
+ return true;
+ }
+
+ // get the number of leading zeros in the bigint.
+ int ctlz() const noexcept {
+ if (vec.is_empty()) {
+ return 0;
+ } else {
+#ifdef FASTFLOAT_64BIT_LIMB
+ return leading_zeroes(vec.rindex(0));
+#else
+ // no use defining a specialized leading_zeroes for a 32-bit type.
+ uint64_t r0 = vec.rindex(0);
+ return leading_zeroes(r0 << 32);
+#endif
+ }
+ }
+
+ // get the number of bits in the bigint.
+ int bit_length() const noexcept {
+ int lz = ctlz();
+ return int(limb_bits * vec.len()) - lz;
+ }
+
+ bool mul(limb y) noexcept {
+ return small_mul(vec, y);
+ }
+
+ bool add(limb y) noexcept {
+ return small_add(vec, y);
+ }
+
+ // multiply as if by 2 raised to a power.
+ bool pow2(uint32_t exp) noexcept {
+ return shl(exp);
+ }
+
+ // multiply as if by 5 raised to a power.
+ bool pow5(uint32_t exp) noexcept {
+ // multiply by a power of 5
+ static constexpr uint32_t large_step = 135;
+ static constexpr uint64_t small_power_of_5[] = {
+ 1UL, 5UL, 25UL, 125UL, 625UL, 3125UL, 15625UL, 78125UL, 390625UL,
+ 1953125UL, 9765625UL, 48828125UL, 244140625UL, 1220703125UL,
+ 6103515625UL, 30517578125UL, 152587890625UL, 762939453125UL,
+ 3814697265625UL, 19073486328125UL, 95367431640625UL, 476837158203125UL,
+ 2384185791015625UL, 11920928955078125UL, 59604644775390625UL,
+ 298023223876953125UL, 1490116119384765625UL, 7450580596923828125UL,
+ };
+#ifdef FASTFLOAT_64BIT_LIMB
+ constexpr static limb large_power_of_5[] = {
+ 1414648277510068013UL, 9180637584431281687UL, 4539964771860779200UL,
+ 10482974169319127550UL, 198276706040285095UL};
+#else
+ constexpr static limb large_power_of_5[] = {
+ 4279965485U, 329373468U, 4020270615U, 2137533757U, 4287402176U,
+ 1057042919U, 1071430142U, 2440757623U, 381945767U, 46164893U};
+#endif
+ size_t large_length = sizeof(large_power_of_5) / sizeof(limb);
+ limb_span large = limb_span(large_power_of_5, large_length);
+ while (exp >= large_step) {
+ FASTFLOAT_TRY(large_mul(vec, large));
+ exp -= large_step;
+ }
+#ifdef FASTFLOAT_64BIT_LIMB
+ uint32_t small_step = 27;
+ limb max_native = 7450580596923828125UL;
+#else
+ uint32_t small_step = 13;
+ limb max_native = 1220703125U;
+#endif
+ while (exp >= small_step) {
+ FASTFLOAT_TRY(small_mul(vec, max_native));
+ exp -= small_step;
+ }
+ if (exp != 0) {
+ FASTFLOAT_TRY(small_mul(vec, limb(small_power_of_5[exp])));
+ }
+
+ return true;
+ }
+
+ // multiply as if by 10 raised to a power.
+ bool pow10(uint32_t exp) noexcept {
+ FASTFLOAT_TRY(pow5(exp));
+ return pow2(exp);
+ }
+};
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_ASCII_NUMBER_H
+#define FASTFLOAT_ASCII_NUMBER_H
+
+#include <cctype>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+
+
+namespace fast_float {
+
+// Next function can be micro-optimized, but compilers are entirely
+// able to optimize it well.
+fastfloat_really_inline bool is_integer(char c) noexcept { return c >= '0' && c <= '9'; }
+
+fastfloat_really_inline uint64_t byteswap(uint64_t val) {
+ return (val & 0xFF00000000000000) >> 56
+ | (val & 0x00FF000000000000) >> 40
+ | (val & 0x0000FF0000000000) >> 24
+ | (val & 0x000000FF00000000) >> 8
+ | (val & 0x00000000FF000000) << 8
+ | (val & 0x0000000000FF0000) << 24
+ | (val & 0x000000000000FF00) << 40
+ | (val & 0x00000000000000FF) << 56;
+}
+
+fastfloat_really_inline uint64_t read_u64(const char *chars) {
+ uint64_t val;
+ ::memcpy(&val, chars, sizeof(uint64_t));
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+ // Need to read as-if the number was in little-endian order.
+ val = byteswap(val);
+#endif
+ return val;
+}
+
+fastfloat_really_inline void write_u64(uint8_t *chars, uint64_t val) {
+#if FASTFLOAT_IS_BIG_ENDIAN == 1
+ // Need to read as-if the number was in little-endian order.
+ val = byteswap(val);
+#endif
+ ::memcpy(chars, &val, sizeof(uint64_t));
+}
+
+// credit @aqrit
+fastfloat_really_inline uint32_t parse_eight_digits_unrolled(uint64_t val) {
+ const uint64_t mask = 0x000000FF000000FF;
+ const uint64_t mul1 = 0x000F424000000064; // 100 + (1000000ULL << 32)
+ const uint64_t mul2 = 0x0000271000000001; // 1 + (10000ULL << 32)
+ val -= 0x3030303030303030;
+ val = (val * 10) + (val >> 8); // val = (val * 2561) >> 8;
+ val = (((val & mask) * mul1) + (((val >> 16) & mask) * mul2)) >> 32;
+ return uint32_t(val);
+}
+
+fastfloat_really_inline uint32_t parse_eight_digits_unrolled(const char *chars) noexcept {
+ return parse_eight_digits_unrolled(read_u64(chars));
+}
+
+// credit @aqrit
+fastfloat_really_inline bool is_made_of_eight_digits_fast(uint64_t val) noexcept {
+ return !((((val + 0x4646464646464646) | (val - 0x3030303030303030)) &
+ 0x8080808080808080));
+}
+
+fastfloat_really_inline bool is_made_of_eight_digits_fast(const char *chars) noexcept {
+ return is_made_of_eight_digits_fast(read_u64(chars));
+}
+
+typedef span<const char> byte_span;
+
+struct parsed_number_string {
+ int64_t exponent{0};
+ uint64_t mantissa{0};
+ const char *lastmatch{nullptr};
+ bool negative{false};
+ bool valid{false};
+ bool too_many_digits{false};
+ // contains the range of the significant digits
+ byte_span integer{}; // non-nullable
+ byte_span fraction{}; // nullable
+};
+
+// Assuming that you use no more than 19 digits, this will
+// parse an ASCII string.
+fastfloat_really_inline
+parsed_number_string parse_number_string(const char *p, const char *pend, parse_options options) noexcept {
+ const chars_format fmt = options.format;
+ const char decimal_point = options.decimal_point;
+
+ parsed_number_string answer;
+ answer.valid = false;
+ answer.too_many_digits = false;
+ answer.negative = (*p == '-');
+ if (*p == '-') { // C++17 20.19.3.(7.1) explicitly forbids '+' sign here
+ ++p;
+ if (p == pend) {
+ return answer;
+ }
+ if (!is_integer(*p) && (*p != decimal_point)) { // a sign must be followed by an integer or the dot
+ return answer;
+ }
+ }
+ const char *const start_digits = p;
+
+ uint64_t i = 0; // an unsigned int avoids signed overflows (which are bad)
+
+ while ((std::distance(p, pend) >= 8) && is_made_of_eight_digits_fast(p)) {
+ i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
+ p += 8;
+ }
+ while ((p != pend) && is_integer(*p)) {
+ // a multiplication by 10 is cheaper than an arbitrary integer
+ // multiplication
+ i = 10 * i +
+ uint64_t(*p - '0'); // might overflow, we will handle the overflow later
+ ++p;
+ }
+ const char *const end_of_integer_part = p;
+ int64_t digit_count = int64_t(end_of_integer_part - start_digits);
+ answer.integer = byte_span(start_digits, size_t(digit_count));
+ int64_t exponent = 0;
+ if ((p != pend) && (*p == decimal_point)) {
+ ++p;
+ const char* before = p;
+ // can occur at most twice without overflowing, but let it occur more, since
+ // for integers with many digits, digit parsing is the primary bottleneck.
+ while ((std::distance(p, pend) >= 8) && is_made_of_eight_digits_fast(p)) {
+ i = i * 100000000 + parse_eight_digits_unrolled(p); // in rare cases, this will overflow, but that's ok
+ p += 8;
+ }
+ while ((p != pend) && is_integer(*p)) {
+ uint8_t digit = uint8_t(*p - '0');
+ ++p;
+ i = i * 10 + digit; // in rare cases, this will overflow, but that's ok
+ }
+ exponent = before - p;
+ answer.fraction = byte_span(before, size_t(p - before));
+ digit_count -= exponent;
+ }
+ // we must have encountered at least one integer!
+ if (digit_count == 0) {
+ return answer;
+ }
+ int64_t exp_number = 0; // explicit exponential part
+ if ((fmt & chars_format::scientific) && (p != pend) && (('e' == *p) || ('E' == *p))) {
+ const char * location_of_e = p;
+ ++p;
+ bool neg_exp = false;
+ if ((p != pend) && ('-' == *p)) {
+ neg_exp = true;
+ ++p;
+ } else if ((p != pend) && ('+' == *p)) { // '+' on exponent is allowed by C++17 20.19.3.(7.1)
+ ++p;
+ }
+ if ((p == pend) || !is_integer(*p)) {
+ if(!(fmt & chars_format::fixed)) {
+ // We are in error.
+ return answer;
+ }
+ // Otherwise, we will be ignoring the 'e'.
+ p = location_of_e;
+ } else {
+ while ((p != pend) && is_integer(*p)) {
+ uint8_t digit = uint8_t(*p - '0');
+ if (exp_number < 0x10000000) {
+ exp_number = 10 * exp_number + digit;
+ }
+ ++p;
+ }
+ if(neg_exp) { exp_number = - exp_number; }
+ exponent += exp_number;
+ }
+ } else {
+ // If it scientific and not fixed, we have to bail out.
+ if((fmt & chars_format::scientific) && !(fmt & chars_format::fixed)) { return answer; }
+ }
+ answer.lastmatch = p;
+ answer.valid = true;
+
+ // If we frequently had to deal with long strings of digits,
+ // we could extend our code by using a 128-bit integer instead
+ // of a 64-bit integer. However, this is uncommon.
+ //
+ // We can deal with up to 19 digits.
+ if (digit_count > 19) { // this is uncommon
+ // It is possible that the integer had an overflow.
+ // We have to handle the case where we have 0.0000somenumber.
+ // We need to be mindful of the case where we only have zeroes...
+ // E.g., 0.000000000...000.
+ const char *start = start_digits;
+ while ((start != pend) && (*start == '0' || *start == decimal_point)) {
+ if(*start == '0') { digit_count --; }
+ start++;
+ }
+ if (digit_count > 19) {
+ answer.too_many_digits = true;
+ // Let us start again, this time, avoiding overflows.
+ // We don't need to check if is_integer, since we use the
+ // pre-tokenized spans from above.
+ i = 0;
+ p = answer.integer.ptr;
+ const char* int_end = p + answer.integer.len();
+ const uint64_t minimal_nineteen_digit_integer{1000000000000000000};
+ while((i < minimal_nineteen_digit_integer) && (p != int_end)) {
+ i = i * 10 + uint64_t(*p - '0');
+ ++p;
+ }
+ if (i >= minimal_nineteen_digit_integer) { // We have a big integers
+ exponent = end_of_integer_part - p + exp_number;
+ } else { // We have a value with a fractional component.
+ p = answer.fraction.ptr;
+ const char* frac_end = p + answer.fraction.len();
+ while((i < minimal_nineteen_digit_integer) && (p != frac_end)) {
+ i = i * 10 + uint64_t(*p - '0');
+ ++p;
+ }
+ exponent = answer.fraction.ptr - p + exp_number;
+ }
+ // We have now corrected both exponent and i, to a truncated value
+ }
+ }
+ answer.exponent = exponent;
+ answer.mantissa = i;
+ return answer;
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_DIGIT_COMPARISON_H
+#define FASTFLOAT_DIGIT_COMPARISON_H
+
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+
+
+namespace fast_float {
+
+// 1e0 to 1e19
+constexpr static uint64_t powers_of_ten_uint64[] = {
+ 1UL, 10UL, 100UL, 1000UL, 10000UL, 100000UL, 1000000UL, 10000000UL, 100000000UL,
+ 1000000000UL, 10000000000UL, 100000000000UL, 1000000000000UL, 10000000000000UL,
+ 100000000000000UL, 1000000000000000UL, 10000000000000000UL, 100000000000000000UL,
+ 1000000000000000000UL, 10000000000000000000UL};
+
+// calculate the exponent, in scientific notation, of the number.
+// this algorithm is not even close to optimized, but it has no practical
+// effect on performance: in order to have a faster algorithm, we'd need
+// to slow down performance for faster algorithms, and this is still fast.
+fastfloat_really_inline int32_t scientific_exponent(parsed_number_string& num) noexcept {
+ uint64_t mantissa = num.mantissa;
+ int32_t exponent = int32_t(num.exponent);
+ while (mantissa >= 10000) {
+ mantissa /= 10000;
+ exponent += 4;
+ }
+ while (mantissa >= 100) {
+ mantissa /= 100;
+ exponent += 2;
+ }
+ while (mantissa >= 10) {
+ mantissa /= 10;
+ exponent += 1;
+ }
+ return exponent;
+}
+
+// this converts a native floating-point number to an extended-precision float.
+template <typename T>
+fastfloat_really_inline adjusted_mantissa to_extended(T value) noexcept {
+ adjusted_mantissa am;
+ int32_t bias = binary_format<T>::mantissa_explicit_bits() - binary_format<T>::minimum_exponent();
+ if (std::is_same<T, float>::value) {
+ constexpr uint32_t exponent_mask = 0x7F800000;
+ constexpr uint32_t mantissa_mask = 0x007FFFFF;
+ constexpr uint64_t hidden_bit_mask = 0x00800000;
+ uint32_t bits;
+ ::memcpy(&bits, &value, sizeof(T));
+ if ((bits & exponent_mask) == 0) {
+ // denormal
+ am.power2 = 1 - bias;
+ am.mantissa = bits & mantissa_mask;
+ } else {
+ // normal
+ am.power2 = int32_t((bits & exponent_mask) >> binary_format<T>::mantissa_explicit_bits());
+ am.power2 -= bias;
+ am.mantissa = (bits & mantissa_mask) | hidden_bit_mask;
+ }
+ } else {
+ constexpr uint64_t exponent_mask = 0x7FF0000000000000;
+ constexpr uint64_t mantissa_mask = 0x000FFFFFFFFFFFFF;
+ constexpr uint64_t hidden_bit_mask = 0x0010000000000000;
+ uint64_t bits;
+ ::memcpy(&bits, &value, sizeof(T));
+ if ((bits & exponent_mask) == 0) {
+ // denormal
+ am.power2 = 1 - bias;
+ am.mantissa = bits & mantissa_mask;
+ } else {
+ // normal
+ am.power2 = int32_t((bits & exponent_mask) >> binary_format<T>::mantissa_explicit_bits());
+ am.power2 -= bias;
+ am.mantissa = (bits & mantissa_mask) | hidden_bit_mask;
+ }
+ }
+
+ return am;
+}
+
+// get the extended precision value of the halfway point between b and b+u.
+// we are given a native float that represents b, so we need to adjust it
+// halfway between b and b+u.
+template <typename T>
+fastfloat_really_inline adjusted_mantissa to_extended_halfway(T value) noexcept {
+ adjusted_mantissa am = to_extended(value);
+ am.mantissa <<= 1;
+ am.mantissa += 1;
+ am.power2 -= 1;
+ return am;
+}
+
+// round an extended-precision float to the nearest machine float.
+template <typename T, typename callback>
+fastfloat_really_inline void round(adjusted_mantissa& am, callback cb) noexcept {
+ int32_t mantissa_shift = 64 - binary_format<T>::mantissa_explicit_bits() - 1;
+ if (-am.power2 >= mantissa_shift) {
+ // have a denormal float
+ int32_t shift = -am.power2 + 1;
+ cb(am, std::min(shift, 64));
+ // check for round-up: if rounding-nearest carried us to the hidden bit.
+ am.power2 = (am.mantissa < (uint64_t(1) << binary_format<T>::mantissa_explicit_bits())) ? 0 : 1;
+ return;
+ }
+
+ // have a normal float, use the default shift.
+ cb(am, mantissa_shift);
+
+ // check for carry
+ if (am.mantissa >= (uint64_t(2) << binary_format<T>::mantissa_explicit_bits())) {
+ am.mantissa = (uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
+ am.power2++;
+ }
+
+ // check for infinite: we could have carried to an infinite power
+ am.mantissa &= ~(uint64_t(1) << binary_format<T>::mantissa_explicit_bits());
+ if (am.power2 >= binary_format<T>::infinite_power()) {
+ am.power2 = binary_format<T>::infinite_power();
+ am.mantissa = 0;
+ }
+}
+
+template <typename callback>
+fastfloat_really_inline
+void round_nearest_tie_even(adjusted_mantissa& am, int32_t shift, callback cb) noexcept {
+ uint64_t mask;
+ uint64_t halfway;
+ if (shift == 64) {
+ mask = UINT64_MAX;
+ } else {
+ mask = (uint64_t(1) << shift) - 1;
+ }
+ if (shift == 0) {
+ halfway = 0;
+ } else {
+ halfway = uint64_t(1) << (shift - 1);
+ }
+ uint64_t truncated_bits = am.mantissa & mask;
+ uint64_t is_above = truncated_bits > halfway;
+ uint64_t is_halfway = truncated_bits == halfway;
+
+ // shift digits into position
+ if (shift == 64) {
+ am.mantissa = 0;
+ } else {
+ am.mantissa >>= shift;
+ }
+ am.power2 += shift;
+
+ bool is_odd = (am.mantissa & 1) == 1;
+ am.mantissa += uint64_t(cb(is_odd, is_halfway, is_above));
+}
+
+fastfloat_really_inline void round_down(adjusted_mantissa& am, int32_t shift) noexcept {
+ if (shift == 64) {
+ am.mantissa = 0;
+ } else {
+ am.mantissa >>= shift;
+ }
+ am.power2 += shift;
+}
+
+fastfloat_really_inline void skip_zeros(const char*& first, const char* last) noexcept {
+ uint64_t val;
+ while (std::distance(first, last) >= 8) {
+ ::memcpy(&val, first, sizeof(uint64_t));
+ if (val != 0x3030303030303030) {
+ break;
+ }
+ first += 8;
+ }
+ while (first != last) {
+ if (*first != '0') {
+ break;
+ }
+ first++;
+ }
+}
+
+// determine if any non-zero digits were truncated.
+// all characters must be valid digits.
+fastfloat_really_inline bool is_truncated(const char* first, const char* last) noexcept {
+ // do 8-bit optimizations, can just compare to 8 literal 0s.
+ uint64_t val;
+ while (std::distance(first, last) >= 8) {
+ ::memcpy(&val, first, sizeof(uint64_t));
+ if (val != 0x3030303030303030) {
+ return true;
+ }
+ first += 8;
+ }
+ while (first != last) {
+ if (*first != '0') {
+ return true;
+ }
+ first++;
+ }
+ return false;
+}
+
+fastfloat_really_inline bool is_truncated(byte_span s) noexcept {
+ return is_truncated(s.ptr, s.ptr + s.len());
+}
+
+fastfloat_really_inline
+void parse_eight_digits(const char*& p, limb& value, size_t& counter, size_t& count) noexcept {
+ value = value * 100000000 + parse_eight_digits_unrolled(p);
+ p += 8;
+ counter += 8;
+ count += 8;
+}
+
+fastfloat_really_inline
+void parse_one_digit(const char*& p, limb& value, size_t& counter, size_t& count) noexcept {
+ value = value * 10 + limb(*p - '0');
+ p++;
+ counter++;
+ count++;
+}
+
+fastfloat_really_inline
+void add_native(bigint& big, limb power, limb value) noexcept {
+ big.mul(power);
+ big.add(value);
+}
+
+fastfloat_really_inline void round_up_bigint(bigint& big, size_t& count) noexcept {
+ // need to round-up the digits, but need to avoid rounding
+ // ....9999 to ...10000, which could cause a false halfway point.
+ add_native(big, 10, 1);
+ count++;
+}
+
+// parse the significant digits into a big integer
+inline void parse_mantissa(bigint& result, parsed_number_string& num, size_t max_digits, size_t& digits) noexcept {
+ // try to minimize the number of big integer and scalar multiplication.
+ // therefore, try to parse 8 digits at a time, and multiply by the largest
+ // scalar value (9 or 19 digits) for each step.
+ size_t counter = 0;
+ digits = 0;
+ limb value = 0;
+#ifdef FASTFLOAT_64BIT_LIMB
+ size_t step = 19;
+#else
+ size_t step = 9;
+#endif
+
+ // process all integer digits.
+ const char* p = num.integer.ptr;
+ const char* pend = p + num.integer.len();
+ skip_zeros(p, pend);
+ // process all digits, in increments of step per loop
+ while (p != pend) {
+ while ((std::distance(p, pend) >= 8) && (step - counter >= 8) && (max_digits - digits >= 8)) {
+ parse_eight_digits(p, value, counter, digits);
+ }
+ while (counter < step && p != pend && digits < max_digits) {
+ parse_one_digit(p, value, counter, digits);
+ }
+ if (digits == max_digits) {
+ // add the temporary value, then check if we've truncated any digits
+ add_native(result, limb(powers_of_ten_uint64[counter]), value);
+ bool truncated = is_truncated(p, pend);
+ if (num.fraction.ptr != nullptr) {
+ truncated |= is_truncated(num.fraction);
+ }
+ if (truncated) {
+ round_up_bigint(result, digits);
+ }
+ return;
+ } else {
+ add_native(result, limb(powers_of_ten_uint64[counter]), value);
+ counter = 0;
+ value = 0;
+ }
+ }
+
+ // add our fraction digits, if they're available.
+ if (num.fraction.ptr != nullptr) {
+ p = num.fraction.ptr;
+ pend = p + num.fraction.len();
+ if (digits == 0) {
+ skip_zeros(p, pend);
+ }
+ // process all digits, in increments of step per loop
+ while (p != pend) {
+ while ((std::distance(p, pend) >= 8) && (step - counter >= 8) && (max_digits - digits >= 8)) {
+ parse_eight_digits(p, value, counter, digits);
+ }
+ while (counter < step && p != pend && digits < max_digits) {
+ parse_one_digit(p, value, counter, digits);
+ }
+ if (digits == max_digits) {
+ // add the temporary value, then check if we've truncated any digits
+ add_native(result, limb(powers_of_ten_uint64[counter]), value);
+ bool truncated = is_truncated(p, pend);
+ if (truncated) {
+ round_up_bigint(result, digits);
+ }
+ return;
+ } else {
+ add_native(result, limb(powers_of_ten_uint64[counter]), value);
+ counter = 0;
+ value = 0;
+ }
+ }
+ }
+
+ if (counter != 0) {
+ add_native(result, limb(powers_of_ten_uint64[counter]), value);
+ }
+}
+
+template <typename T>
+inline adjusted_mantissa positive_digit_comp(bigint& bigmant, int32_t exponent) noexcept {
+ FASTFLOAT_ASSERT(bigmant.pow10(uint32_t(exponent)));
+ adjusted_mantissa answer;
+ bool truncated;
+ answer.mantissa = bigmant.hi64(truncated);
+ int bias = binary_format<T>::mantissa_explicit_bits() - binary_format<T>::minimum_exponent();
+ answer.power2 = bigmant.bit_length() - 64 + bias;
+
+ round<T>(answer, [truncated](adjusted_mantissa& a, int32_t shift) {
+ round_nearest_tie_even(a, shift, [truncated](bool is_odd, bool is_halfway, bool is_above) -> bool {
+ return is_above || (is_halfway && truncated) || (is_odd && is_halfway);
+ });
+ });
+
+ return answer;
+}
+
+// the scaling here is quite simple: we have, for the real digits `m * 10^e`,
+// and for the theoretical digits `n * 2^f`. Since `e` is always negative,
+// to scale them identically, we do `n * 2^f * 5^-f`, so we now have `m * 2^e`.
+// we then need to scale by `2^(f- e)`, and then the two significant digits
+// are of the same magnitude.
+template <typename T>
+inline adjusted_mantissa negative_digit_comp(bigint& bigmant, adjusted_mantissa am, int32_t exponent) noexcept {
+ bigint& real_digits = bigmant;
+ int32_t real_exp = exponent;
+
+ // get the value of `b`, rounded down, and get a bigint representation of b+h
+ adjusted_mantissa am_b = am;
+ // gcc7 buf: use a lambda to remove the noexcept qualifier bug with -Wnoexcept-type.
+ round<T>(am_b, [](adjusted_mantissa&a, int32_t shift) { round_down(a, shift); });
+ T b;
+ to_float(false, am_b, b);
+ adjusted_mantissa theor = to_extended_halfway(b);
+ bigint theor_digits(theor.mantissa);
+ int32_t theor_exp = theor.power2;
+
+ // scale real digits and theor digits to be same power.
+ int32_t pow2_exp = theor_exp - real_exp;
+ uint32_t pow5_exp = uint32_t(-real_exp);
+ if (pow5_exp != 0) {
+ FASTFLOAT_ASSERT(theor_digits.pow5(pow5_exp));
+ }
+ if (pow2_exp > 0) {
+ FASTFLOAT_ASSERT(theor_digits.pow2(uint32_t(pow2_exp)));
+ } else if (pow2_exp < 0) {
+ FASTFLOAT_ASSERT(real_digits.pow2(uint32_t(-pow2_exp)));
+ }
+
+ // compare digits, and use it to director rounding
+ int ord = real_digits.compare(theor_digits);
+ adjusted_mantissa answer = am;
+ round<T>(answer, [ord](adjusted_mantissa& a, int32_t shift) {
+ round_nearest_tie_even(a, shift, [ord](bool is_odd, bool _, bool __) -> bool {
+ (void)_; // not needed, since we've done our comparison
+ (void)__; // not needed, since we've done our comparison
+ if (ord > 0) {
+ return true;
+ } else if (ord < 0) {
+ return false;
+ } else {
+ return is_odd;
+ }
+ });
+ });
+
+ return answer;
+}
+
+// parse the significant digits as a big integer to unambiguously round the
+// the significant digits. here, we are trying to determine how to round
+// an extended float representation close to `b+h`, halfway between `b`
+// (the float rounded-down) and `b+u`, the next positive float. this
+// algorithm is always correct, and uses one of two approaches. when
+// the exponent is positive relative to the significant digits (such as
+// 1234), we create a big-integer representation, get the high 64-bits,
+// determine if any lower bits are truncated, and use that to direct
+// rounding. in case of a negative exponent relative to the significant
+// digits (such as 1.2345), we create a theoretical representation of
+// `b` as a big-integer type, scaled to the same binary exponent as
+// the actual digits. we then compare the big integer representations
+// of both, and use that to direct rounding.
+template <typename T>
+inline adjusted_mantissa digit_comp(parsed_number_string& num, adjusted_mantissa am) noexcept {
+ // remove the invalid exponent bias
+ am.power2 -= invalid_am_bias;
+
+ int32_t sci_exp = scientific_exponent(num);
+ size_t max_digits = binary_format<T>::max_digits();
+ size_t digits = 0;
+ bigint bigmant;
+ parse_mantissa(bigmant, num, max_digits, digits);
+ // can't underflow, since digits is at most max_digits.
+ int32_t exponent = sci_exp + 1 - int32_t(digits);
+ if (exponent >= 0) {
+ return positive_digit_comp<T>(bigmant, exponent);
+ } else {
+ return negative_digit_comp<T>(bigmant, am, exponent);
+ }
+}
+
+} // namespace fast_float
+
+#endif
+
+#ifndef FASTFLOAT_PARSE_NUMBER_H
+#define FASTFLOAT_PARSE_NUMBER_H
+
+
+#include <cmath>
+#include <cstring>
+#include <limits>
+#include <system_error>
+
+namespace fast_float {
+
+
+namespace detail {
+/**
+ * Special case +inf, -inf, nan, infinity, -infinity.
+ * The case comparisons could be made much faster given that we know that the
+ * strings a null-free and fixed.
+ **/
+template <typename T>
+from_chars_result parse_infnan(const char *first, const char *last, T &value) noexcept {
+ from_chars_result answer;
+ answer.ptr = first;
+ answer.ec = std::errc(); // be optimistic
+ bool minusSign = false;
+ if (*first == '-') { // assume first < last, so dereference without checks; C++17 20.19.3.(7.1) explicitly forbids '+' here
+ minusSign = true;
+ ++first;
+ }
+ if (last - first >= 3) {
+ if (fastfloat_strncasecmp(first, "nan", 3)) {
+ answer.ptr = (first += 3);
+ value = minusSign ? -std::numeric_limits<T>::quiet_NaN() : std::numeric_limits<T>::quiet_NaN();
+ // Check for possible nan(n-char-seq-opt), C++17 20.19.3.7, C11 7.20.1.3.3. At least MSVC produces nan(ind) and nan(snan).
+ if(first != last && *first == '(') {
+ for(const char* ptr = first + 1; ptr != last; ++ptr) {
+ if (*ptr == ')') {
+ answer.ptr = ptr + 1; // valid nan(n-char-seq-opt)
+ break;
+ }
+ else if(!(('a' <= *ptr && *ptr <= 'z') || ('A' <= *ptr && *ptr <= 'Z') || ('0' <= *ptr && *ptr <= '9') || *ptr == '_'))
+ break; // forbidden char, not nan(n-char-seq-opt)
+ }
+ }
+ return answer;
+ }
+ if (fastfloat_strncasecmp(first, "inf", 3)) {
+ if ((last - first >= 8) && fastfloat_strncasecmp(first + 3, "inity", 5)) {
+ answer.ptr = first + 8;
+ } else {
+ answer.ptr = first + 3;
+ }
+ value = minusSign ? -std::numeric_limits<T>::infinity() : std::numeric_limits<T>::infinity();
+ return answer;
+ }
+ }
+ answer.ec = std::errc::invalid_argument;
+ return answer;
+}
+
+} // namespace detail
+
+template<typename T>
+from_chars_result from_chars(const char *first, const char *last,
+ T &value, chars_format fmt /*= chars_format::general*/) noexcept {
+ return from_chars_advanced(first, last, value, parse_options{fmt});
+}
+
+template<typename T>
+from_chars_result from_chars_advanced(const char *first, const char *last,
+ T &value, parse_options options) noexcept {
+
+ static_assert (std::is_same<T, double>::value || std::is_same<T, float>::value, "only float and double are supported");
+
+
+ from_chars_result answer;
+ if (first == last) {
+ answer.ec = std::errc::invalid_argument;
+ answer.ptr = first;
+ return answer;
+ }
+ parsed_number_string pns = parse_number_string(first, last, options);
+ if (!pns.valid) {
+ return detail::parse_infnan(first, last, value);
+ }
+ answer.ec = std::errc(); // be optimistic
+ answer.ptr = pns.lastmatch;
+ // Next is Clinger's fast path.
+ if (binary_format<T>::min_exponent_fast_path() <= pns.exponent && pns.exponent <= binary_format<T>::max_exponent_fast_path() && pns.mantissa <=binary_format<T>::max_mantissa_fast_path() && !pns.too_many_digits) {
+ value = T(pns.mantissa);
+ if (pns.exponent < 0) { value = value / binary_format<T>::exact_power_of_ten(-pns.exponent); }
+ else { value = value * binary_format<T>::exact_power_of_ten(pns.exponent); }
+ if (pns.negative) { value = -value; }
+ return answer;
+ }
+ adjusted_mantissa am = compute_float<binary_format<T>>(pns.exponent, pns.mantissa);
+ if(pns.too_many_digits && am.power2 >= 0) {
+ if(am != compute_float<binary_format<T>>(pns.exponent, pns.mantissa + 1)) {
+ am = compute_error<binary_format<T>>(pns.exponent, pns.mantissa);
+ }
+ }
+ // If we called compute_float<binary_format<T>>(pns.exponent, pns.mantissa) and we have an invalid power (am.power2 < 0),
+ // then we need to go the long way around again. This is very uncommon.
+ if(am.power2 < 0) { am = digit_comp<T>(pns, am); }
+ to_float(pns.negative, am, value);
+ return answer;
+}
+
+} // namespace fast_float
+
+#endif
+
--
2.35.0.rc1
^ permalink raw reply [flat|nested] 15+ messages in thread
* [PATCH 3/6] libstdc++: Apply modifications to our local copy of fast_float
2022-01-16 18:06 [PATCH 1/6 v2] libstdc++: Directly implement hexfloat std::from_chars for binary32/64 Patrick Palka
2022-01-16 18:06 ` [PATCH 2/6] libstdc++: Import the fast_float library Patrick Palka
@ 2022-01-16 18:06 ` Patrick Palka
2022-01-17 10:46 ` Jonathan Wakely
2022-01-16 18:06 ` [PATCH 4/6] libstdc++: Adjust fast_float's over/underflow behavior for conformnace Patrick Palka
` (3 subsequent siblings)
5 siblings, 1 reply; 15+ messages in thread
From: Patrick Palka @ 2022-01-16 18:06 UTC (permalink / raw)
To: gcc-patches; +Cc: libstdc++, Patrick Palka
This performs the following modifications to our local copy of fast_float
in order to make it more readily usable in our std::from_chars
implementation:
* Remove system #includes
* Replace stray call to assert
* Use the standard chars_format and from_chars_result types
libstdc++-v3/ChangeLog:
* src/c++17/fast_float/LOCAL_PATCHES: Update.
* src/c++17/fast_float/fast_float.h: Apply local modifications.
---
.../src/c++17/fast_float/LOCAL_PATCHES | 1 +
.../src/c++17/fast_float/fast_float.h | 62 ++-----------------
2 files changed, 7 insertions(+), 56 deletions(-)
diff --git a/libstdc++-v3/src/c++17/fast_float/LOCAL_PATCHES b/libstdc++-v3/src/c++17/fast_float/LOCAL_PATCHES
index e69de29bb2d..e9d7bba6195 100644
--- a/libstdc++-v3/src/c++17/fast_float/LOCAL_PATCHES
+++ b/libstdc++-v3/src/c++17/fast_float/LOCAL_PATCHES
@@ -0,0 +1 @@
+r12-????
diff --git a/libstdc++-v3/src/c++17/fast_float/fast_float.h b/libstdc++-v3/src/c++17/fast_float/fast_float.h
index 8a45ebca8a8..c908719ec3a 100644
--- a/libstdc++-v3/src/c++17/fast_float/fast_float.h
+++ b/libstdc++-v3/src/c++17/fast_float/fast_float.h
@@ -42,21 +42,10 @@
#ifndef FASTFLOAT_FAST_FLOAT_H
#define FASTFLOAT_FAST_FLOAT_H
-#include <system_error>
-
namespace fast_float {
-enum chars_format {
- scientific = 1<<0,
- fixed = 1<<2,
- hex = 1<<3,
- general = fixed | scientific
-};
-
-struct from_chars_result {
- const char *ptr;
- std::errc ec;
-};
+using std::chars_format;
+using std::from_chars_result;
struct parse_options {
constexpr explicit parse_options(chars_format fmt = chars_format::general,
@@ -105,11 +94,6 @@ from_chars_result from_chars_advanced(const char *first, const char *last,
#ifndef FASTFLOAT_FLOAT_COMMON_H
#define FASTFLOAT_FLOAT_COMMON_H
-#include <cfloat>
-#include <cstdint>
-#include <cassert>
-#include <cstring>
-
#if (defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) \
|| defined(__amd64) || defined(__aarch64__) || defined(_M_ARM64) \
|| defined(__MINGW64__) \
@@ -233,7 +217,7 @@ struct value128 {
/* result might be undefined when input_num is zero */
fastfloat_really_inline int leading_zeroes(uint64_t input_num) {
- assert(input_num > 0);
+ FASTFLOAT_DEBUG_ASSERT(input_num > 0);
#ifdef FASTFLOAT_VISUAL_STUDIO
#if defined(_M_X64) || defined(_M_ARM64)
unsigned long leading_zero = 0;
@@ -468,11 +452,6 @@ fastfloat_really_inline void to_float(bool negative, adjusted_mantissa am, T &va
#ifndef FASTFLOAT_ASCII_NUMBER_H
#define FASTFLOAT_ASCII_NUMBER_H
-#include <cctype>
-#include <cstdint>
-#include <cstring>
-#include <iterator>
-
namespace fast_float {
@@ -610,7 +589,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, parse_
return answer;
}
int64_t exp_number = 0; // explicit exponential part
- if ((fmt & chars_format::scientific) && (p != pend) && (('e' == *p) || ('E' == *p))) {
+ if (bool(fmt & chars_format::scientific) && (p != pend) && (('e' == *p) || ('E' == *p))) {
const char * location_of_e = p;
++p;
bool neg_exp = false;
@@ -621,7 +600,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, parse_
++p;
}
if ((p == pend) || !is_integer(*p)) {
- if(!(fmt & chars_format::fixed)) {
+ if(!bool(fmt & chars_format::fixed)) {
// We are in error.
return answer;
}
@@ -640,7 +619,7 @@ parsed_number_string parse_number_string(const char *p, const char *pend, parse_
}
} else {
// If it scientific and not fixed, we have to bail out.
- if((fmt & chars_format::scientific) && !(fmt & chars_format::fixed)) { return answer; }
+ if(bool(fmt & chars_format::scientific) && !bool(fmt & chars_format::fixed)) { return answer; }
}
answer.lastmatch = p;
answer.valid = true;
@@ -699,8 +678,6 @@ parsed_number_string parse_number_string(const char *p, const char *pend, parse_
#ifndef FASTFLOAT_FAST_TABLE_H
#define FASTFLOAT_FAST_TABLE_H
-#include <cstdint>
-
namespace fast_float {
/**
@@ -1399,13 +1376,6 @@ using powers = powers_template<>;
#ifndef FASTFLOAT_DECIMAL_TO_BINARY_H
#define FASTFLOAT_DECIMAL_TO_BINARY_H
-#include <cfloat>
-#include <cinttypes>
-#include <cmath>
-#include <cstdint>
-#include <cstdlib>
-#include <cstring>
-
namespace fast_float {
// This will compute or rather approximate w * 5**q and return a pair of 64-bit words approximating
@@ -1592,11 +1562,6 @@ adjusted_mantissa compute_float(int64_t q, uint64_t w) noexcept {
#ifndef FASTFLOAT_BIGINT_H
#define FASTFLOAT_BIGINT_H
-#include <algorithm>
-#include <cstdint>
-#include <climits>
-#include <cstring>
-
namespace fast_float {
@@ -2182,11 +2147,6 @@ struct bigint {
#ifndef FASTFLOAT_ASCII_NUMBER_H
#define FASTFLOAT_ASCII_NUMBER_H
-#include <cctype>
-#include <cstdint>
-#include <cstring>
-#include <iterator>
-
namespace fast_float {
@@ -2413,11 +2373,6 @@ parsed_number_string parse_number_string(const char *p, const char *pend, parse_
#ifndef FASTFLOAT_DIGIT_COMPARISON_H
#define FASTFLOAT_DIGIT_COMPARISON_H
-#include <algorithm>
-#include <cstdint>
-#include <cstring>
-#include <iterator>
-
namespace fast_float {
@@ -2835,11 +2790,6 @@ inline adjusted_mantissa digit_comp(parsed_number_string& num, adjusted_mantissa
#define FASTFLOAT_PARSE_NUMBER_H
-#include <cmath>
-#include <cstring>
-#include <limits>
-#include <system_error>
-
namespace fast_float {
--
2.35.0.rc1
^ permalink raw reply [flat|nested] 15+ messages in thread
* [PATCH 4/6] libstdc++: Adjust fast_float's over/underflow behavior for conformnace
2022-01-16 18:06 [PATCH 1/6 v2] libstdc++: Directly implement hexfloat std::from_chars for binary32/64 Patrick Palka
2022-01-16 18:06 ` [PATCH 2/6] libstdc++: Import the fast_float library Patrick Palka
2022-01-16 18:06 ` [PATCH 3/6] libstdc++: Apply modifications to our local copy of fast_float Patrick Palka
@ 2022-01-16 18:06 ` Patrick Palka
2022-01-17 10:49 ` Jonathan Wakely
2022-01-16 18:06 ` [PATCH 5/6] libstdc++: Use fast_float in std::from_chars for binary32/64 Patrick Palka
` (2 subsequent siblings)
5 siblings, 1 reply; 15+ messages in thread
From: Patrick Palka @ 2022-01-16 18:06 UTC (permalink / raw)
To: gcc-patches; +Cc: libstdc++, Patrick Palka
This makes fast_float handle the situation where std::from_chars is
specified to return result_out_of_range, i.e. when the parsed value
is outside the representable range of the floating-point type.
This adjusts fast_float's behavior in case of over/underflow: instead of
returning errc{} and setting value to +-0 or +-infinity, return
result_out_of_range and don't modify value, as per [charconv.from.chars]/1.
libstdc++-v3/ChangeLog:
* src/c++17/fast_float/LOCAL_PATCHES: Update.
* src/c++17/fast_float/fast_float.h (from_chars_advanced): In
case of over/underflow, return errc::result_out_of_range and don't
modify 'value'.
---
libstdc++-v3/src/c++17/fast_float/LOCAL_PATCHES | 1 +
libstdc++-v3/src/c++17/fast_float/fast_float.h | 9 +++++++++
2 files changed, 10 insertions(+)
diff --git a/libstdc++-v3/src/c++17/fast_float/LOCAL_PATCHES b/libstdc++-v3/src/c++17/fast_float/LOCAL_PATCHES
index e9d7bba6195..1f90f9d1d85 100644
--- a/libstdc++-v3/src/c++17/fast_float/LOCAL_PATCHES
+++ b/libstdc++-v3/src/c++17/fast_float/LOCAL_PATCHES
@@ -1 +1,2 @@
r12-????
+r12-????
diff --git a/libstdc++-v3/src/c++17/fast_float/fast_float.h b/libstdc++-v3/src/c++17/fast_float/fast_float.h
index c908719ec3a..97d28940944 100644
--- a/libstdc++-v3/src/c++17/fast_float/fast_float.h
+++ b/libstdc++-v3/src/c++17/fast_float/fast_float.h
@@ -2884,6 +2884,15 @@ from_chars_result from_chars_advanced(const char *first, const char *last,
// If we called compute_float<binary_format<T>>(pns.exponent, pns.mantissa) and we have an invalid power (am.power2 < 0),
// then we need to go the long way around again. This is very uncommon.
if(am.power2 < 0) { am = digit_comp<T>(pns, am); }
+
+ if((pns.mantissa != 0 && am.mantissa == 0 && am.power2 == 0) || am.power2 == binary_format<T>::infinite_power()) {
+ // In case of over/underflow, return result_out_of_range and don't modify value,
+ // as per [charconv.from.chars]/1. Note that LWG 3081 wants to modify value in
+ // this case too.
+ answer.ec = std::errc::result_out_of_range;
+ return answer;
+ }
+
to_float(pns.negative, am, value);
return answer;
}
--
2.35.0.rc1
^ permalink raw reply [flat|nested] 15+ messages in thread
* [PATCH 5/6] libstdc++: Use fast_float in std::from_chars for binary32/64
2022-01-16 18:06 [PATCH 1/6 v2] libstdc++: Directly implement hexfloat std::from_chars for binary32/64 Patrick Palka
` (2 preceding siblings ...)
2022-01-16 18:06 ` [PATCH 4/6] libstdc++: Adjust fast_float's over/underflow behavior for conformnace Patrick Palka
@ 2022-01-16 18:06 ` Patrick Palka
2022-01-17 10:50 ` Jonathan Wakely
2022-01-16 18:06 ` [PATCH 6/6] libstdc++: Import MSVC floating-point std::from_chars testcases Patrick Palka
2022-01-17 10:34 ` [PATCH 1/6 v2] libstdc++: Directly implement hexfloat std::from_chars for binary32/64 Jonathan Wakely
5 siblings, 1 reply; 15+ messages in thread
From: Patrick Palka @ 2022-01-16 18:06 UTC (permalink / raw)
To: gcc-patches; +Cc: libstdc++, Patrick Palka
This makes our std::from_chars implementation use fast_float for parsing
chars_format::scientific/fixed/general parsing into binary32/64 values.
For other floating-point formats we still use the fallback implementation
that goes through the strtod family of functions.
libstdc++-v3/ChangeLog:
* src/c++17/floating_from_chars.cc: (USE_LIB_FAST_FLOAT):
Conditionally define, and use it to conditionally include
fast_float.
(from_chars): Use fast_float for float and double when
USE_LIB_FAST_FLOAT.
---
libstdc++-v3/src/c++17/floating_from_chars.cc | 31 ++++++++++++++++---
1 file changed, 27 insertions(+), 4 deletions(-)
diff --git a/libstdc++-v3/src/c++17/floating_from_chars.cc b/libstdc++-v3/src/c++17/floating_from_chars.cc
index b186da9a955..c340eb18ea8 100644
--- a/libstdc++-v3/src/c++17/floating_from_chars.cc
+++ b/libstdc++-v3/src/c++17/floating_from_chars.cc
@@ -35,6 +35,7 @@
#include <string>
#include <memory_resource>
#include <cfenv>
+#include <cfloat>
#include <cmath>
#include <cstdlib>
#include <cstring>
@@ -53,6 +54,18 @@
extern "C" __ieee128 __strtoieee128(const char*, char**);
#endif
+#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64
+# define USE_LIB_FAST_FLOAT 1
+#endif
+
+#if USE_LIB_FAST_FLOAT
+# define FASTFLOAT_DEBUG_ASSERT __glibcxx_assert
+namespace
+{
+# include "fast_float/fast_float.h"
+} // anon namespace
+#endif
+
#if _GLIBCXX_HAVE_USELOCALE
namespace std _GLIBCXX_VISIBILITY(default)
{
@@ -775,8 +788,12 @@ from_chars(const char* first, const char* last, float& value,
#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64
if (fmt == chars_format::hex)
return __floating_from_chars_hex(first, last, value);
-#endif
-
+ else
+ {
+ static_assert(USE_LIB_FAST_FLOAT);
+ return fast_float::from_chars(first, last, value, fmt);
+ }
+#else
errc ec = errc::invalid_argument;
#if _GLIBCXX_USE_CXX11_ABI
buffer_resource mr;
@@ -797,6 +814,7 @@ from_chars(const char* first, const char* last, float& value,
fmt = chars_format{};
}
return make_result(first, len, fmt, ec);
+#endif
}
from_chars_result
@@ -806,8 +824,12 @@ from_chars(const char* first, const char* last, double& value,
#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64
if (fmt == chars_format::hex)
return __floating_from_chars_hex(first, last, value);
-#endif
-
+ else
+ {
+ static_assert(USE_LIB_FAST_FLOAT);
+ return fast_float::from_chars(first, last, value, fmt);
+ }
+#else
errc ec = errc::invalid_argument;
#if _GLIBCXX_USE_CXX11_ABI
buffer_resource mr;
@@ -828,6 +850,7 @@ from_chars(const char* first, const char* last, double& value,
fmt = chars_format{};
}
return make_result(first, len, fmt, ec);
+#endif
}
from_chars_result
--
2.35.0.rc1
^ permalink raw reply [flat|nested] 15+ messages in thread
* [PATCH 6/6] libstdc++: Import MSVC floating-point std::from_chars testcases
2022-01-16 18:06 [PATCH 1/6 v2] libstdc++: Directly implement hexfloat std::from_chars for binary32/64 Patrick Palka
` (3 preceding siblings ...)
2022-01-16 18:06 ` [PATCH 5/6] libstdc++: Use fast_float in std::from_chars for binary32/64 Patrick Palka
@ 2022-01-16 18:06 ` Patrick Palka
2022-01-17 10:54 ` Jonathan Wakely
2022-01-17 10:34 ` [PATCH 1/6 v2] libstdc++: Directly implement hexfloat std::from_chars for binary32/64 Jonathan Wakely
5 siblings, 1 reply; 15+ messages in thread
From: Patrick Palka @ 2022-01-16 18:06 UTC (permalink / raw)
To: gcc-patches; +Cc: libstdc++, Patrick Palka
libstdc++-v3/ChangeLog:
* testsuite/20_util/from_chars/double.cc: New test, consisting
of testcases extracted from the MSVC STL testsuite.
* testsuite/20_util/from_chars/float.cc: New test.
---
.../testsuite/20_util/from_chars/double.cc | 1674 +++++++++++++++++
.../testsuite/20_util/from_chars/float.cc | 290 +++
2 files changed, 1964 insertions(+)
create mode 100644 libstdc++-v3/testsuite/20_util/from_chars/double.cc
create mode 100644 libstdc++-v3/testsuite/20_util/from_chars/float.cc
diff --git a/libstdc++-v3/testsuite/20_util/from_chars/double.cc b/libstdc++-v3/testsuite/20_util/from_chars/double.cc
new file mode 100644
index 00000000000..ce53a1c56c2
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/from_chars/double.cc
@@ -0,0 +1,1674 @@
+// This file consists of testcases extracted from the MSVC STL testsuite.
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// { dg-do run { target c++17 } }
+// { dg-require-effective-target ieee_floats }
+
+#include <charconv>
+
+#include <limits>
+#include <cstring>
+#include <testsuite_hooks.h>
+
+using namespace std;
+
+inline constexpr double double_inf = numeric_limits<double>::infinity();
+
+struct double_from_chars_testcase {
+ const char* input;
+ chars_format fmt;
+ size_t correct_idx;
+ errc correct_ec;
+ double correct_value;
+};
+
+inline constexpr double_from_chars_testcase double_from_chars_test_cases[] = {
+ {"1.000000000000a000", chars_format::hex, 18, errc{}, 0x1.000000000000ap0}, // exact
+ {"1.000000000000a001", chars_format::hex, 18, errc{}, 0x1.000000000000ap0}, // below midpoint, round down
+ {"1.000000000000a800", chars_format::hex, 18, errc{}, 0x1.000000000000ap0}, // midpoint, round down to even
+ {"1.000000000000a801", chars_format::hex, 18, errc{}, 0x1.000000000000bp0}, // above midpoint, round up
+ {"1.000000000000b000", chars_format::hex, 18, errc{}, 0x1.000000000000bp0}, // exact
+ {"1.000000000000b001", chars_format::hex, 18, errc{}, 0x1.000000000000bp0}, // below midpoint, round down
+ {"1.000000000000b800", chars_format::hex, 18, errc{}, 0x1.000000000000cp0}, // midpoint, round up to even
+ {"1.000000000000b801", chars_format::hex, 18, errc{}, 0x1.000000000000cp0}, // above midpoint, round up
+
+ {"1.00000000000020", chars_format::hex, 16, errc{}, 0x1.0000000000002p0}, // exact
+ {"1.00000000000021", chars_format::hex, 16, errc{}, 0x1.0000000000002p0}, // below midpoint, round down
+ {"1.00000000000028", chars_format::hex, 16, errc{}, 0x1.0000000000002p0}, // midpoint, round down to even
+ {"1.00000000000029", chars_format::hex, 16, errc{}, 0x1.0000000000003p0}, // above midpoint, round up
+ {"1.00000000000030", chars_format::hex, 16, errc{}, 0x1.0000000000003p0}, // exact
+ {"1.00000000000031", chars_format::hex, 16, errc{}, 0x1.0000000000003p0}, // below midpoint, round down
+ {"1.00000000000038", chars_format::hex, 16, errc{}, 0x1.0000000000004p0}, // midpoint, round up to even
+ {"1.00000000000039", chars_format::hex, 16, errc{}, 0x1.0000000000004p0}, // above midpoint, round up
+
+ {"1.00000000000000044408920985006261616945266723632812500000", chars_format::general, 58, errc{},
+ 0x1.0000000000002p0}, // exact
+ {"1.00000000000000045796699765787707292474806308746337890625", chars_format::general, 58, errc{},
+ 0x1.0000000000002p0}, // below midpoint, round down
+ {"1.00000000000000055511151231257827021181583404541015624999", chars_format::general, 58, errc{},
+ 0x1.0000000000002p0}, // below midpoint, round down
+ {"1.00000000000000055511151231257827021181583404541015625000", chars_format::general, 58, errc{},
+ 0x1.0000000000002p0}, // midpoint, round down to even
+ {"1.00000000000000055511151231257827021181583404541015625001", chars_format::general, 58, errc{},
+ 0x1.0000000000003p0}, // above midpoint, round up
+ {"1.00000000000000056898930012039272696711122989654541015625", chars_format::general, 58, errc{},
+ 0x1.0000000000003p0}, // above midpoint, round up
+ {"1.00000000000000066613381477509392425417900085449218750000", chars_format::general, 58, errc{},
+ 0x1.0000000000003p0}, // exact
+ {"1.00000000000000068001160258290838100947439670562744140625", chars_format::general, 58, errc{},
+ 0x1.0000000000003p0}, // below midpoint, round down
+ {"1.00000000000000077715611723760957829654216766357421874999", chars_format::general, 58, errc{},
+ 0x1.0000000000003p0}, // below midpoint, round down
+ {"1.00000000000000077715611723760957829654216766357421875000", chars_format::general, 58, errc{},
+ 0x1.0000000000004p0}, // midpoint, round up to even
+ {"1.00000000000000077715611723760957829654216766357421875001", chars_format::general, 58, errc{},
+ 0x1.0000000000004p0}, // above midpoint, round up
+ {"1.00000000000000079103390504542403505183756351470947265625", chars_format::general, 58, errc{},
+ 0x1.0000000000004p0}, // above midpoint, round up
+
+ // https://www.exploringbinary.com/nondeterministic-floating-point-conversions-in-java/
+ {"0.0000008p-1022", chars_format::hex, 15, errc{}, 0x0.0000008p-1022},
+
+ // VSO-838635 "<charconv>: from_chars() mishandles certain subnormals"
+ // These values change on half-ulp boundaries:
+ // 1 * 2^-1075 ~= 2.47e-324 (half-ulp between zero and min subnormal)
+ // 2 * 2^-1075 ~= 4.94e-324 (min subnormal)
+ // 3 * 2^-1075 ~= 7.41e-324 (half-ulp between min subnormal and next subnormal)
+ // 4 * 2^-1075 ~= 9.88e-324 (next subnormal)
+ {"1."
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111e-324",
+ chars_format::scientific, 1007, errc::result_out_of_range, 0x0.0000000000000p+0},
+ {"2."
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222e-324",
+ chars_format::scientific, 1007, errc::result_out_of_range, 0x0.0000000000000p+0},
+ {"3."
+ "3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333"
+ "3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333"
+ "3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333"
+ "3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333"
+ "3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333"
+ "3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333"
+ "3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333"
+ "3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333"
+ "3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333"
+ "3333333333333333333e-324",
+ chars_format::scientific, 1007, errc{}, 0x0.0000000000001p-1022},
+ {"4."
+ "4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444"
+ "4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444"
+ "4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444"
+ "4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444"
+ "4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444"
+ "4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444"
+ "4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444"
+ "4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444"
+ "4444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444"
+ "4444444444444444444e-324",
+ chars_format::scientific, 1007, errc{}, 0x0.0000000000001p-1022},
+ {"5."
+ "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555"
+ "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555"
+ "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555"
+ "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555"
+ "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555"
+ "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555"
+ "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555"
+ "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555"
+ "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555"
+ "5555555555555555555e-324",
+ chars_format::scientific, 1007, errc{}, 0x0.0000000000001p-1022},
+ {"6."
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666e-324",
+ chars_format::scientific, 1007, errc{}, 0x0.0000000000001p-1022},
+ {"7."
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777e-324",
+ chars_format::scientific, 1007, errc{}, 0x0.0000000000002p-1022},
+ {"8."
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888e-324",
+ chars_format::scientific, 1007, errc{}, 0x0.0000000000002p-1022},
+ {"9."
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999e-324",
+ chars_format::scientific, 1007, errc{}, 0x0.0000000000002p-1022},
+
+ // VSO-852024: Test cases for round-to-nearest, ties-to-even.
+ // Consider the values:
+ // A: 0x1.0000000000000p+0 == 1.0000000000000000000000000000000000000000000000000000
+ // X: (1 + 2^-53) * 2^0 == 1.00000000000000011102230246251565404236316680908203125
+ // B: 0x1.0000000000001p+0 == 1.0000000000000002220446049250313080847263336181640625
+ // X is equidistant from A and B. Because they're tied for being nearest, we need to round to even.
+ // That means rounding down to A, because A's least significant hexit 0 is even.
+ // However, values between X and B aren't tied - they're simply nearer to B, so they need to round up to B.
+ // We need to handle tricky cases like the digits of X, followed by a million 0 digits, followed by a 1 digit.
+ // Similarly:
+ // E: 0x1.ffffffffffffep+0 == 1.999999999999999555910790149937383830547332763671875
+ // Y: (1 + 1 - 3 * 2^-53) * 2^0 == 1.99999999999999966693309261245303787291049957275390625
+ // F: 0x1.fffffffffffffp+0 == 1.9999999999999997779553950749686919152736663818359375
+ // The hexit E is 14 and even, while F is 15 and odd.
+
+ // just below (0 + 2^-53) * 2^-1022: decremented last digit, then appended three 9 digits
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002470"
+ "3282292062327208828439643411068618252990130716238221279284125033775363510437593264991818081799618989828234772"
+ "2858865463328355177969898199387398005390939063150356595155702263922908583924491051844359318028499365361525003"
+ "1937045767824921936562366986365848075700158576926990370631192827955855133292783433840935197801553124659726357"
+ "9574622766465272827220056374006485499977096599470454020828166226237857393450736339007967761930577506740176324"
+ "6736009689513405355374585166611342237666786041621596804619144672918403005300575308490487653917113865916462395"
+ "2491262365388187963623937328042389101867234849766823508986338858792562830275599565752445550725518931369083625"
+ "4779186948667994968324049705821028513185451396213837722826145437693412532098591327667236328124999",
+ chars_format::fixed, 1080, errc::result_out_of_range, 0x0.0000000000000p+0},
+
+ // (0 + 2^-53) * 2^-1022 exactly
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002470"
+ "3282292062327208828439643411068618252990130716238221279284125033775363510437593264991818081799618989828234772"
+ "2858865463328355177969898199387398005390939063150356595155702263922908583924491051844359318028499365361525003"
+ "1937045767824921936562366986365848075700158576926990370631192827955855133292783433840935197801553124659726357"
+ "9574622766465272827220056374006485499977096599470454020828166226237857393450736339007967761930577506740176324"
+ "6736009689513405355374585166611342237666786041621596804619144672918403005300575308490487653917113865916462395"
+ "2491262365388187963623937328042389101867234849766823508986338858792562830275599565752445550725518931369083625"
+ "4779186948667994968324049705821028513185451396213837722826145437693412532098591327667236328125",
+ chars_format::fixed, 1077, errc::result_out_of_range, 0x0.0000000000000p+0},
+
+ // (0 + 2^-53) * 2^-1022 exactly, followed by a thousand 0 digits
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002470"
+ "3282292062327208828439643411068618252990130716238221279284125033775363510437593264991818081799618989828234772"
+ "2858865463328355177969898199387398005390939063150356595155702263922908583924491051844359318028499365361525003"
+ "1937045767824921936562366986365848075700158576926990370631192827955855133292783433840935197801553124659726357"
+ "9574622766465272827220056374006485499977096599470454020828166226237857393450736339007967761930577506740176324"
+ "6736009689513405355374585166611342237666786041621596804619144672918403005300575308490487653917113865916462395"
+ "2491262365388187963623937328042389101867234849766823508986338858792562830275599565752445550725518931369083625"
+ "4779186948667994968324049705821028513185451396213837722826145437693412532098591327667236328125000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000",
+ chars_format::fixed, 2077, errc::result_out_of_range, 0x0.0000000000000p+0},
+
+ // above (0 + 2^-53) * 2^-1022: appended a thousand 0 digits followed by a 1 digit
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002470"
+ "3282292062327208828439643411068618252990130716238221279284125033775363510437593264991818081799618989828234772"
+ "2858865463328355177969898199387398005390939063150356595155702263922908583924491051844359318028499365361525003"
+ "1937045767824921936562366986365848075700158576926990370631192827955855133292783433840935197801553124659726357"
+ "9574622766465272827220056374006485499977096599470454020828166226237857393450736339007967761930577506740176324"
+ "6736009689513405355374585166611342237666786041621596804619144672918403005300575308490487653917113865916462395"
+ "2491262365388187963623937328042389101867234849766823508986338858792562830275599565752445550725518931369083625"
+ "4779186948667994968324049705821028513185451396213837722826145437693412532098591327667236328125000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00001",
+ chars_format::fixed, 2078, errc{}, 0x0.0000000000001p-1022},
+
+ // above (0 + 2^-53) * 2^-1022: appended a 1 digit
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002470"
+ "3282292062327208828439643411068618252990130716238221279284125033775363510437593264991818081799618989828234772"
+ "2858865463328355177969898199387398005390939063150356595155702263922908583924491051844359318028499365361525003"
+ "1937045767824921936562366986365848075700158576926990370631192827955855133292783433840935197801553124659726357"
+ "9574622766465272827220056374006485499977096599470454020828166226237857393450736339007967761930577506740176324"
+ "6736009689513405355374585166611342237666786041621596804619144672918403005300575308490487653917113865916462395"
+ "2491262365388187963623937328042389101867234849766823508986338858792562830275599565752445550725518931369083625"
+ "47791869486679949683240497058210285131854513962138377228261454376934125320985913276672363281251",
+ chars_format::fixed, 1078, errc{}, 0x0.0000000000001p-1022},
+
+ // above (0 + 2^-53) * 2^-1022: incremented last digit
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002470"
+ "3282292062327208828439643411068618252990130716238221279284125033775363510437593264991818081799618989828234772"
+ "2858865463328355177969898199387398005390939063150356595155702263922908583924491051844359318028499365361525003"
+ "1937045767824921936562366986365848075700158576926990370631192827955855133292783433840935197801553124659726357"
+ "9574622766465272827220056374006485499977096599470454020828166226237857393450736339007967761930577506740176324"
+ "6736009689513405355374585166611342237666786041621596804619144672918403005300575308490487653917113865916462395"
+ "2491262365388187963623937328042389101867234849766823508986338858792562830275599565752445550725518931369083625"
+ "4779186948667994968324049705821028513185451396213837722826145437693412532098591327667236328126",
+ chars_format::fixed, 1077, errc{}, 0x0.0000000000001p-1022},
+
+ // just below (0 + 1 - 3 * 2^-53) * 2^-1022: decremented last digit, then appended three 9 digits
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072006419"
+ "9176395546258779936602667813027328296362349540005779643539444484102225369938322261431279727704724131030539099"
+ "2976863718870946851468024222968583977359185141028540361975476844303195813273469348201130421165308554532083149"
+ "3676067608324920106709384047261543474082573017216837765643921010648239116172158852475760231303527077156200284"
+ "1775343298712758123539074213191978739083589771549597066404661620550578925994422322342444472859570416955675758"
+ "5423752417124134805999073137808018133811049489046686648944255834488901008259721496147104204399198556535697531"
+ "0055231935448663898095485089604066035268185282450207861510244351362091237759797852153577038777504570568436147"
+ "5530270683064113556748943345076587312006145811358486831521563686919762403704226016998291015624999",
+ chars_format::fixed, 1080, errc{}, 0x0.ffffffffffffep-1022},
+
+ // (0 + 1 - 3 * 2^-53) * 2^-1022 exactly
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072006419"
+ "9176395546258779936602667813027328296362349540005779643539444484102225369938322261431279727704724131030539099"
+ "2976863718870946851468024222968583977359185141028540361975476844303195813273469348201130421165308554532083149"
+ "3676067608324920106709384047261543474082573017216837765643921010648239116172158852475760231303527077156200284"
+ "1775343298712758123539074213191978739083589771549597066404661620550578925994422322342444472859570416955675758"
+ "5423752417124134805999073137808018133811049489046686648944255834488901008259721496147104204399198556535697531"
+ "0055231935448663898095485089604066035268185282450207861510244351362091237759797852153577038777504570568436147"
+ "5530270683064113556748943345076587312006145811358486831521563686919762403704226016998291015625",
+ chars_format::fixed, 1077, errc{}, 0x0.ffffffffffffep-1022},
+
+ // (0 + 1 - 3 * 2^-53) * 2^-1022 exactly, followed by a thousand 0 digits
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072006419"
+ "9176395546258779936602667813027328296362349540005779643539444484102225369938322261431279727704724131030539099"
+ "2976863718870946851468024222968583977359185141028540361975476844303195813273469348201130421165308554532083149"
+ "3676067608324920106709384047261543474082573017216837765643921010648239116172158852475760231303527077156200284"
+ "1775343298712758123539074213191978739083589771549597066404661620550578925994422322342444472859570416955675758"
+ "5423752417124134805999073137808018133811049489046686648944255834488901008259721496147104204399198556535697531"
+ "0055231935448663898095485089604066035268185282450207861510244351362091237759797852153577038777504570568436147"
+ "5530270683064113556748943345076587312006145811358486831521563686919762403704226016998291015625000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000",
+ chars_format::fixed, 2077, errc{}, 0x0.ffffffffffffep-1022},
+
+ // above (0 + 1 - 3 * 2^-53) * 2^-1022: appended a thousand 0 digits followed by a 1 digit
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072006419"
+ "9176395546258779936602667813027328296362349540005779643539444484102225369938322261431279727704724131030539099"
+ "2976863718870946851468024222968583977359185141028540361975476844303195813273469348201130421165308554532083149"
+ "3676067608324920106709384047261543474082573017216837765643921010648239116172158852475760231303527077156200284"
+ "1775343298712758123539074213191978739083589771549597066404661620550578925994422322342444472859570416955675758"
+ "5423752417124134805999073137808018133811049489046686648944255834488901008259721496147104204399198556535697531"
+ "0055231935448663898095485089604066035268185282450207861510244351362091237759797852153577038777504570568436147"
+ "5530270683064113556748943345076587312006145811358486831521563686919762403704226016998291015625000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00001",
+ chars_format::fixed, 2078, errc{}, 0x0.fffffffffffffp-1022},
+
+ // above (0 + 1 - 3 * 2^-53) * 2^-1022: appended a 1 digit
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072006419"
+ "9176395546258779936602667813027328296362349540005779643539444484102225369938322261431279727704724131030539099"
+ "2976863718870946851468024222968583977359185141028540361975476844303195813273469348201130421165308554532083149"
+ "3676067608324920106709384047261543474082573017216837765643921010648239116172158852475760231303527077156200284"
+ "1775343298712758123539074213191978739083589771549597066404661620550578925994422322342444472859570416955675758"
+ "5423752417124134805999073137808018133811049489046686648944255834488901008259721496147104204399198556535697531"
+ "0055231935448663898095485089604066035268185282450207861510244351362091237759797852153577038777504570568436147"
+ "55302706830641135567489433450765873120061458113584868315215636869197624037042260169982910156251",
+ chars_format::fixed, 1078, errc{}, 0x0.fffffffffffffp-1022},
+
+ // above (0 + 1 - 3 * 2^-53) * 2^-1022: incremented last digit
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072006419"
+ "9176395546258779936602667813027328296362349540005779643539444484102225369938322261431279727704724131030539099"
+ "2976863718870946851468024222968583977359185141028540361975476844303195813273469348201130421165308554532083149"
+ "3676067608324920106709384047261543474082573017216837765643921010648239116172158852475760231303527077156200284"
+ "1775343298712758123539074213191978739083589771549597066404661620550578925994422322342444472859570416955675758"
+ "5423752417124134805999073137808018133811049489046686648944255834488901008259721496147104204399198556535697531"
+ "0055231935448663898095485089604066035268185282450207861510244351362091237759797852153577038777504570568436147"
+ "5530270683064113556748943345076587312006145811358486831521563686919762403704226016998291015626",
+ chars_format::fixed, 1077, errc{}, 0x0.fffffffffffffp-1022},
+
+ // just below (1 + 2^-53) * 2^-1022: decremented last digit, then appended three 9 digits
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072016301"
+ "2305563795567615250361241457301801308322872404958664760675944619203679411688695321398552054903200090343478188"
+ "4412325572184367563347617020518175998922941393629966742598285899994830148971433555578567693279306015978183162"
+ "1424250679624607852958851992724935776883207324924799248168692322471659649343292587839501022509739575795105716"
+ "0073834364573849432419299709217920738991976169431413149717326525502008499797367678374315520581880443916381057"
+ "2367791175177756227497413804253387084478193655533073867420834526162513029462022730109054820067654020201547112"
+ "0020281397001415752591234401773622442737124681517501897455599786532342558862196115163359241679580296044770649"
+ "4647018477736093430045142168360701364747951396213837722826145437693412532098591327667236328124999",
+ chars_format::fixed, 1080, errc{}, 0x1.0000000000000p-1022},
+
+ // (1 + 2^-53) * 2^-1022 exactly
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072016301"
+ "2305563795567615250361241457301801308322872404958664760675944619203679411688695321398552054903200090343478188"
+ "4412325572184367563347617020518175998922941393629966742598285899994830148971433555578567693279306015978183162"
+ "1424250679624607852958851992724935776883207324924799248168692322471659649343292587839501022509739575795105716"
+ "0073834364573849432419299709217920738991976169431413149717326525502008499797367678374315520581880443916381057"
+ "2367791175177756227497413804253387084478193655533073867420834526162513029462022730109054820067654020201547112"
+ "0020281397001415752591234401773622442737124681517501897455599786532342558862196115163359241679580296044770649"
+ "4647018477736093430045142168360701364747951396213837722826145437693412532098591327667236328125",
+ chars_format::fixed, 1077, errc{}, 0x1.0000000000000p-1022},
+
+ // (1 + 2^-53) * 2^-1022 exactly, followed by a thousand 0 digits
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072016301"
+ "2305563795567615250361241457301801308322872404958664760675944619203679411688695321398552054903200090343478188"
+ "4412325572184367563347617020518175998922941393629966742598285899994830148971433555578567693279306015978183162"
+ "1424250679624607852958851992724935776883207324924799248168692322471659649343292587839501022509739575795105716"
+ "0073834364573849432419299709217920738991976169431413149717326525502008499797367678374315520581880443916381057"
+ "2367791175177756227497413804253387084478193655533073867420834526162513029462022730109054820067654020201547112"
+ "0020281397001415752591234401773622442737124681517501897455599786532342558862196115163359241679580296044770649"
+ "4647018477736093430045142168360701364747951396213837722826145437693412532098591327667236328125000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000",
+ chars_format::fixed, 2077, errc{}, 0x1.0000000000000p-1022},
+
+ // above (1 + 2^-53) * 2^-1022: appended a thousand 0 digits followed by a 1 digit
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072016301"
+ "2305563795567615250361241457301801308322872404958664760675944619203679411688695321398552054903200090343478188"
+ "4412325572184367563347617020518175998922941393629966742598285899994830148971433555578567693279306015978183162"
+ "1424250679624607852958851992724935776883207324924799248168692322471659649343292587839501022509739575795105716"
+ "0073834364573849432419299709217920738991976169431413149717326525502008499797367678374315520581880443916381057"
+ "2367791175177756227497413804253387084478193655533073867420834526162513029462022730109054820067654020201547112"
+ "0020281397001415752591234401773622442737124681517501897455599786532342558862196115163359241679580296044770649"
+ "4647018477736093430045142168360701364747951396213837722826145437693412532098591327667236328125000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00001",
+ chars_format::fixed, 2078, errc{}, 0x1.0000000000001p-1022},
+
+ // above (1 + 2^-53) * 2^-1022: appended a 1 digit
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072016301"
+ "2305563795567615250361241457301801308322872404958664760675944619203679411688695321398552054903200090343478188"
+ "4412325572184367563347617020518175998922941393629966742598285899994830148971433555578567693279306015978183162"
+ "1424250679624607852958851992724935776883207324924799248168692322471659649343292587839501022509739575795105716"
+ "0073834364573849432419299709217920738991976169431413149717326525502008499797367678374315520581880443916381057"
+ "2367791175177756227497413804253387084478193655533073867420834526162513029462022730109054820067654020201547112"
+ "0020281397001415752591234401773622442737124681517501897455599786532342558862196115163359241679580296044770649"
+ "46470184777360934300451421683607013647479513962138377228261454376934125320985913276672363281251",
+ chars_format::fixed, 1078, errc{}, 0x1.0000000000001p-1022},
+
+ // above (1 + 2^-53) * 2^-1022: incremented last digit
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072016301"
+ "2305563795567615250361241457301801308322872404958664760675944619203679411688695321398552054903200090343478188"
+ "4412325572184367563347617020518175998922941393629966742598285899994830148971433555578567693279306015978183162"
+ "1424250679624607852958851992724935776883207324924799248168692322471659649343292587839501022509739575795105716"
+ "0073834364573849432419299709217920738991976169431413149717326525502008499797367678374315520581880443916381057"
+ "2367791175177756227497413804253387084478193655533073867420834526162513029462022730109054820067654020201547112"
+ "0020281397001415752591234401773622442737124681517501897455599786532342558862196115163359241679580296044770649"
+ "4647018477736093430045142168360701364747951396213837722826145437693412532098591327667236328126",
+ chars_format::fixed, 1077, errc{}, 0x1.0000000000001p-1022},
+
+ // just below (1 + 1 - 3 * 2^-53) * 2^-1022: decremented last digit, then appended three 9 digits
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044501477170144020250"
+ "8199667279499186358524265859260511351695091228726223124931264069530541271189424317838013700808305231545782515"
+ "4530323827726959236845743044099361970891187471508150509418060480375117378320411851935338796416115205148741308"
+ "3163272520124606023105869053620631175265621765214646643181420505164043632222668006474326056011713528291579642"
+ "2274554896821334728738317548403413978098469341510556195293821919814730032341053661708792231510873354131880491"
+ "1055533902788485678121901775450062980622457102958163711745945687733011032421168917765671370549738710820782247"
+ "7584250967061891687062782163335299376138075114200886249979505279101870966346394401564490729731565935244123171"
+ "5398102212132212018470035807616260163568645811358486831521563686919762403704226016998291015624999",
+ chars_format::fixed, 1080, errc{}, 0x1.ffffffffffffep-1022},
+
+ // (1 + 1 - 3 * 2^-53) * 2^-1022 exactly
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044501477170144020250"
+ "8199667279499186358524265859260511351695091228726223124931264069530541271189424317838013700808305231545782515"
+ "4530323827726959236845743044099361970891187471508150509418060480375117378320411851935338796416115205148741308"
+ "3163272520124606023105869053620631175265621765214646643181420505164043632222668006474326056011713528291579642"
+ "2274554896821334728738317548403413978098469341510556195293821919814730032341053661708792231510873354131880491"
+ "1055533902788485678121901775450062980622457102958163711745945687733011032421168917765671370549738710820782247"
+ "7584250967061891687062782163335299376138075114200886249979505279101870966346394401564490729731565935244123171"
+ "5398102212132212018470035807616260163568645811358486831521563686919762403704226016998291015625",
+ chars_format::fixed, 1077, errc{}, 0x1.ffffffffffffep-1022},
+
+ // (1 + 1 - 3 * 2^-53) * 2^-1022 exactly, followed by a thousand 0 digits
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044501477170144020250"
+ "8199667279499186358524265859260511351695091228726223124931264069530541271189424317838013700808305231545782515"
+ "4530323827726959236845743044099361970891187471508150509418060480375117378320411851935338796416115205148741308"
+ "3163272520124606023105869053620631175265621765214646643181420505164043632222668006474326056011713528291579642"
+ "2274554896821334728738317548403413978098469341510556195293821919814730032341053661708792231510873354131880491"
+ "1055533902788485678121901775450062980622457102958163711745945687733011032421168917765671370549738710820782247"
+ "7584250967061891687062782163335299376138075114200886249979505279101870966346394401564490729731565935244123171"
+ "5398102212132212018470035807616260163568645811358486831521563686919762403704226016998291015625000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000",
+ chars_format::fixed, 2077, errc{}, 0x1.ffffffffffffep-1022},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^-1022: appended a thousand 0 digits followed by a 1 digit
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044501477170144020250"
+ "8199667279499186358524265859260511351695091228726223124931264069530541271189424317838013700808305231545782515"
+ "4530323827726959236845743044099361970891187471508150509418060480375117378320411851935338796416115205148741308"
+ "3163272520124606023105869053620631175265621765214646643181420505164043632222668006474326056011713528291579642"
+ "2274554896821334728738317548403413978098469341510556195293821919814730032341053661708792231510873354131880491"
+ "1055533902788485678121901775450062980622457102958163711745945687733011032421168917765671370549738710820782247"
+ "7584250967061891687062782163335299376138075114200886249979505279101870966346394401564490729731565935244123171"
+ "5398102212132212018470035807616260163568645811358486831521563686919762403704226016998291015625000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00001",
+ chars_format::fixed, 2078, errc{}, 0x1.fffffffffffffp-1022},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^-1022: appended a 1 digit
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044501477170144020250"
+ "8199667279499186358524265859260511351695091228726223124931264069530541271189424317838013700808305231545782515"
+ "4530323827726959236845743044099361970891187471508150509418060480375117378320411851935338796416115205148741308"
+ "3163272520124606023105869053620631175265621765214646643181420505164043632222668006474326056011713528291579642"
+ "2274554896821334728738317548403413978098469341510556195293821919814730032341053661708792231510873354131880491"
+ "1055533902788485678121901775450062980622457102958163711745945687733011032421168917765671370549738710820782247"
+ "7584250967061891687062782163335299376138075114200886249979505279101870966346394401564490729731565935244123171"
+ "53981022121322120184700358076162601635686458113584868315215636869197624037042260169982910156251",
+ chars_format::fixed, 1078, errc{}, 0x1.fffffffffffffp-1022},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^-1022: incremented last digit
+ {"0."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044501477170144020250"
+ "8199667279499186358524265859260511351695091228726223124931264069530541271189424317838013700808305231545782515"
+ "4530323827726959236845743044099361970891187471508150509418060480375117378320411851935338796416115205148741308"
+ "3163272520124606023105869053620631175265621765214646643181420505164043632222668006474326056011713528291579642"
+ "2274554896821334728738317548403413978098469341510556195293821919814730032341053661708792231510873354131880491"
+ "1055533902788485678121901775450062980622457102958163711745945687733011032421168917765671370549738710820782247"
+ "7584250967061891687062782163335299376138075114200886249979505279101870966346394401564490729731565935244123171"
+ "5398102212132212018470035807616260163568645811358486831521563686919762403704226016998291015626",
+ chars_format::fixed, 1077, errc{}, 0x1.fffffffffffffp-1022},
+
+ // just below (1 + 2^-53) * 2^-33: decremented last digit, then appended three 9 digits
+ {"0.00000000011641532182693482737782207114105741986576081359316958696581423282623291015624999", chars_format::fixed,
+ 91, errc{}, 0x1.0000000000000p-33},
+
+ // (1 + 2^-53) * 2^-33 exactly
+ {"0.00000000011641532182693482737782207114105741986576081359316958696581423282623291015625", chars_format::fixed,
+ 88, errc{}, 0x1.0000000000000p-33},
+
+ // (1 + 2^-53) * 2^-33 exactly, followed by a thousand 0 digits
+ {"0."
+ "0000000001164153218269348273778220711410574198657608135931695869658142328262329101562500000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ chars_format::fixed, 1088, errc{}, 0x1.0000000000000p-33},
+
+ // above (1 + 2^-53) * 2^-33: appended a thousand 0 digits followed by a 1 digit
+ {"0."
+ "0000000001164153218269348273778220711410574198657608135931695869658142328262329101562500000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001",
+ chars_format::fixed, 1089, errc{}, 0x1.0000000000001p-33},
+
+ // above (1 + 2^-53) * 2^-33: appended a 1 digit
+ {"0.000000000116415321826934827377822071141057419865760813593169586965814232826232910156251", chars_format::fixed,
+ 89, errc{}, 0x1.0000000000001p-33},
+
+ // above (1 + 2^-53) * 2^-33: incremented last digit
+ {"0.00000000011641532182693482737782207114105741986576081359316958696581423282623291015626", chars_format::fixed,
+ 88, errc{}, 0x1.0000000000001p-33},
+
+ // just below (1 + 1 - 3 * 2^-53) * 2^-33: decremented last digit, then appended three 9 digits
+ {"0.00000000023283064365386959013215878657682774040271755922049123910255730152130126953124999", chars_format::fixed,
+ 91, errc{}, 0x1.ffffffffffffep-33},
+
+ // (1 + 1 - 3 * 2^-53) * 2^-33 exactly
+ {"0.00000000023283064365386959013215878657682774040271755922049123910255730152130126953125", chars_format::fixed,
+ 88, errc{}, 0x1.ffffffffffffep-33},
+
+ // (1 + 1 - 3 * 2^-53) * 2^-33 exactly, followed by a thousand 0 digits
+ {"0."
+ "0000000002328306436538695901321587865768277404027175592204912391025573015213012695312500000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ chars_format::fixed, 1088, errc{}, 0x1.ffffffffffffep-33},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^-33: appended a thousand 0 digits followed by a 1 digit
+ {"0."
+ "0000000002328306436538695901321587865768277404027175592204912391025573015213012695312500000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001",
+ chars_format::fixed, 1089, errc{}, 0x1.fffffffffffffp-33},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^-33: appended a 1 digit
+ {"0.000000000232830643653869590132158786576827740402717559220491239102557301521301269531251", chars_format::fixed,
+ 89, errc{}, 0x1.fffffffffffffp-33},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^-33: incremented last digit
+ {"0.00000000023283064365386959013215878657682774040271755922049123910255730152130126953126", chars_format::fixed,
+ 88, errc{}, 0x1.fffffffffffffp-33},
+
+ // just below (1 + 2^-53) * 2^0: decremented last digit, then appended three 9 digits
+ {"1.00000000000000011102230246251565404236316680908203124999", chars_format::fixed, 58, errc{},
+ 0x1.0000000000000p+0},
+
+ // (1 + 2^-53) * 2^0 exactly
+ {"1.00000000000000011102230246251565404236316680908203125", chars_format::fixed, 55, errc{}, 0x1.0000000000000p+0},
+
+ // (1 + 2^-53) * 2^0 exactly, followed by a thousand 0 digits
+ {"1."
+ "0000000000000001110223024625156540423631668090820312500000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "000000000000000000000000000000000000000000000000000000000000000000000000",
+ chars_format::fixed, 1055, errc{}, 0x1.0000000000000p+0},
+
+ // above (1 + 2^-53) * 2^0: appended a thousand 0 digits followed by a 1 digit
+ {"1."
+ "0000000000000001110223024625156540423631668090820312500000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000001",
+ chars_format::fixed, 1056, errc{}, 0x1.0000000000001p+0},
+
+ // above (1 + 2^-53) * 2^0: appended a 1 digit
+ {"1.000000000000000111022302462515654042363166809082031251", chars_format::fixed, 56, errc{}, 0x1.0000000000001p+0},
+
+ // above (1 + 2^-53) * 2^0: incremented last digit
+ {"1.00000000000000011102230246251565404236316680908203126", chars_format::fixed, 55, errc{}, 0x1.0000000000001p+0},
+
+ // just below (1 + 1 - 3 * 2^-53) * 2^0: decremented last digit, then appended three 9 digits
+ {"1.99999999999999966693309261245303787291049957275390624999", chars_format::fixed, 58, errc{},
+ 0x1.ffffffffffffep+0},
+
+ // (1 + 1 - 3 * 2^-53) * 2^0 exactly
+ {"1.99999999999999966693309261245303787291049957275390625", chars_format::fixed, 55, errc{}, 0x1.ffffffffffffep+0},
+
+ // (1 + 1 - 3 * 2^-53) * 2^0 exactly, followed by a thousand 0 digits
+ {"1."
+ "9999999999999996669330926124530378729104995727539062500000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "000000000000000000000000000000000000000000000000000000000000000000000000",
+ chars_format::fixed, 1055, errc{}, 0x1.ffffffffffffep+0},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^0: appended a thousand 0 digits followed by a 1 digit
+ {"1."
+ "9999999999999996669330926124530378729104995727539062500000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000001",
+ chars_format::fixed, 1056, errc{}, 0x1.fffffffffffffp+0},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^0: appended a 1 digit
+ {"1.999999999999999666933092612453037872910499572753906251", chars_format::fixed, 56, errc{}, 0x1.fffffffffffffp+0},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^0: incremented last digit
+ {"1.99999999999999966693309261245303787291049957275390626", chars_format::fixed, 55, errc{}, 0x1.fffffffffffffp+0},
+
+ // just below (1 + 2^-53) * 2^33: decremented last digit, then appended three 9 digits
+ {"8589934592.00000095367431640624999", chars_format::fixed, 34, errc{}, 0x1.0000000000000p+33},
+
+ // (1 + 2^-53) * 2^33 exactly
+ {"8589934592.00000095367431640625", chars_format::fixed, 31, errc{}, 0x1.0000000000000p+33},
+
+ // (1 + 2^-53) * 2^33 exactly, followed by a thousand 0 digits
+ {"8589934592."
+ "0000009536743164062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "000000000000000000000000000000000000000",
+ chars_format::fixed, 1031, errc{}, 0x1.0000000000000p+33},
+
+ // above (1 + 2^-53) * 2^33: appended a thousand 0 digits followed by a 1 digit
+ {"8589934592."
+ "0000009536743164062500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000001",
+ chars_format::fixed, 1032, errc{}, 0x1.0000000000001p+33},
+
+ // above (1 + 2^-53) * 2^33: appended a 1 digit
+ {"8589934592.000000953674316406251", chars_format::fixed, 32, errc{}, 0x1.0000000000001p+33},
+
+ // above (1 + 2^-53) * 2^33: incremented last digit
+ {"8589934592.00000095367431640626", chars_format::fixed, 31, errc{}, 0x1.0000000000001p+33},
+
+ // just below (1 + 1 - 3 * 2^-53) * 2^33: decremented last digit, then appended three 9 digits
+ {"17179869183.99999713897705078124999", chars_format::fixed, 35, errc{}, 0x1.ffffffffffffep+33},
+
+ // (1 + 1 - 3 * 2^-53) * 2^33 exactly
+ {"17179869183.99999713897705078125", chars_format::fixed, 32, errc{}, 0x1.ffffffffffffep+33},
+
+ // (1 + 1 - 3 * 2^-53) * 2^33 exactly, followed by a thousand 0 digits
+ {"17179869183."
+ "9999971389770507812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "000000000000000000000000000000000000000",
+ chars_format::fixed, 1032, errc{}, 0x1.ffffffffffffep+33},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^33: appended a thousand 0 digits followed by a 1 digit
+ {"17179869183."
+ "9999971389770507812500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000001",
+ chars_format::fixed, 1033, errc{}, 0x1.fffffffffffffp+33},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^33: appended a 1 digit
+ {"17179869183.999997138977050781251", chars_format::fixed, 33, errc{}, 0x1.fffffffffffffp+33},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^33: incremented last digit
+ {"17179869183.99999713897705078126", chars_format::fixed, 32, errc{}, 0x1.fffffffffffffp+33},
+
+ // just below (1 + 2^-53) * 2^77: decremented last digit, then appended three 9 digits
+ {"151115727451828663615487.999", chars_format::fixed, 28, errc{}, 0x1.0000000000000p+77},
+
+ // (1 + 2^-53) * 2^77 exactly
+ {"151115727451828663615488", chars_format::fixed, 24, errc{}, 0x1.0000000000000p+77},
+
+ // (1 + 2^-53) * 2^77 exactly, followed by a thousand 0 digits
+ {"151115727451828663615488."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000",
+ chars_format::fixed, 1025, errc{}, 0x1.0000000000000p+77},
+
+ // above (1 + 2^-53) * 2^77: appended a thousand 0 digits followed by a 1 digit
+ {"151115727451828663615488."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000001",
+ chars_format::fixed, 1026, errc{}, 0x1.0000000000001p+77},
+
+ // above (1 + 2^-53) * 2^77: appended a 1 digit
+ {"151115727451828663615488.1", chars_format::fixed, 26, errc{}, 0x1.0000000000001p+77},
+
+ // above (1 + 2^-53) * 2^77: incremented last digit
+ {"151115727451828663615489", chars_format::fixed, 24, errc{}, 0x1.0000000000001p+77},
+
+ // just below (1 + 1 - 3 * 2^-53) * 2^77: decremented last digit, then appended three 9 digits
+ {"302231454903657243344895.999", chars_format::fixed, 28, errc{}, 0x1.ffffffffffffep+77},
+
+ // (1 + 1 - 3 * 2^-53) * 2^77 exactly
+ {"302231454903657243344896", chars_format::fixed, 24, errc{}, 0x1.ffffffffffffep+77},
+
+ // (1 + 1 - 3 * 2^-53) * 2^77 exactly, followed by a thousand 0 digits
+ {"302231454903657243344896."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000",
+ chars_format::fixed, 1025, errc{}, 0x1.ffffffffffffep+77},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^77: appended a thousand 0 digits followed by a 1 digit
+ {"302231454903657243344896."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000001",
+ chars_format::fixed, 1026, errc{}, 0x1.fffffffffffffp+77},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^77: appended a 1 digit
+ {"302231454903657243344896.1", chars_format::fixed, 26, errc{}, 0x1.fffffffffffffp+77},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^77: incremented last digit
+ {"302231454903657243344897", chars_format::fixed, 24, errc{}, 0x1.fffffffffffffp+77},
+
+ // just below (1 + 2^-53) * 2^1023: decremented last digit, then appended three 9 digits
+ {"8988465674311580536566680721305029496276241413130815897397134275615404541548669375241369800602409693534988440"
+ "3114202125541629105369684531108613657287705365884742938136589844238179474556051429647415148697857438797685859"
+ "063890851407391008830874765563025951597582513936655578157348020066364210154316532161708031.999",
+ chars_format::fixed, 312, errc{}, 0x1.0000000000000p+1023},
+
+ // (1 + 2^-53) * 2^1023 exactly
+ {"8988465674311580536566680721305029496276241413130815897397134275615404541548669375241369800602409693534988440"
+ "3114202125541629105369684531108613657287705365884742938136589844238179474556051429647415148697857438797685859"
+ "063890851407391008830874765563025951597582513936655578157348020066364210154316532161708032",
+ chars_format::fixed, 308, errc{}, 0x1.0000000000000p+1023},
+
+ // (1 + 2^-53) * 2^1023 exactly, followed by a thousand 0 digits
+ {"8988465674311580536566680721305029496276241413130815897397134275615404541548669375241369800602409693534988440"
+ "3114202125541629105369684531108613657287705365884742938136589844238179474556051429647415148697857438797685859"
+ "063890851407391008830874765563025951597582513936655578157348020066364210154316532161708032."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000",
+ chars_format::fixed, 1309, errc{}, 0x1.0000000000000p+1023},
+
+ // above (1 + 2^-53) * 2^1023: appended a thousand 0 digits followed by a 1 digit
+ {"8988465674311580536566680721305029496276241413130815897397134275615404541548669375241369800602409693534988440"
+ "3114202125541629105369684531108613657287705365884742938136589844238179474556051429647415148697857438797685859"
+ "063890851407391008830874765563025951597582513936655578157348020066364210154316532161708032."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000001",
+ chars_format::fixed, 1310, errc{}, 0x1.0000000000001p+1023},
+
+ // above (1 + 2^-53) * 2^1023: appended a 1 digit
+ {"8988465674311580536566680721305029496276241413130815897397134275615404541548669375241369800602409693534988440"
+ "3114202125541629105369684531108613657287705365884742938136589844238179474556051429647415148697857438797685859"
+ "063890851407391008830874765563025951597582513936655578157348020066364210154316532161708032.1",
+ chars_format::fixed, 310, errc{}, 0x1.0000000000001p+1023},
+
+ // above (1 + 2^-53) * 2^1023: incremented last digit
+ {"8988465674311580536566680721305029496276241413130815897397134275615404541548669375241369800602409693534988440"
+ "3114202125541629105369684531108613657287705365884742938136589844238179474556051429647415148697857438797685859"
+ "063890851407391008830874765563025951597582513936655578157348020066364210154316532161708033",
+ chars_format::fixed, 308, errc{}, 0x1.0000000000001p+1023},
+
+ // just below (1 + 1 - 3 * 2^-53) * 2^1023: decremented last digit, then appended three 9 digits
+ {"1797693134862315608353258760581052985162070023416521662616611746258695532672923265745300992879465492467506314"
+ "9033587701752208710592698796290627760473556921329019091915239418047621712533496094635638726128664019802903779"
+ "9514183602981511756283727771403830521483963923935633133642802139091669457927874464075218943.999",
+ chars_format::fixed, 313, errc{}, 0x1.ffffffffffffep+1023},
+
+ // (1 + 1 - 3 * 2^-53) * 2^1023 exactly
+ {"1797693134862315608353258760581052985162070023416521662616611746258695532672923265745300992879465492467506314"
+ "9033587701752208710592698796290627760473556921329019091915239418047621712533496094635638726128664019802903779"
+ "9514183602981511756283727771403830521483963923935633133642802139091669457927874464075218944",
+ chars_format::fixed, 309, errc{}, 0x1.ffffffffffffep+1023},
+
+ // (1 + 1 - 3 * 2^-53) * 2^1023 exactly, followed by a thousand 0 digits
+ {"1797693134862315608353258760581052985162070023416521662616611746258695532672923265745300992879465492467506314"
+ "9033587701752208710592698796290627760473556921329019091915239418047621712533496094635638726128664019802903779"
+ "9514183602981511756283727771403830521483963923935633133642802139091669457927874464075218944."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000",
+ chars_format::fixed, 1310, errc{}, 0x1.ffffffffffffep+1023},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^1023: appended a thousand 0 digits followed by a 1 digit
+ {"1797693134862315608353258760581052985162070023416521662616611746258695532672923265745300992879465492467506314"
+ "9033587701752208710592698796290627760473556921329019091915239418047621712533496094635638726128664019802903779"
+ "9514183602981511756283727771403830521483963923935633133642802139091669457927874464075218944."
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000001",
+ chars_format::fixed, 1311, errc{}, 0x1.fffffffffffffp+1023},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^1023: appended a 1 digit
+ {"1797693134862315608353258760581052985162070023416521662616611746258695532672923265745300992879465492467506314"
+ "9033587701752208710592698796290627760473556921329019091915239418047621712533496094635638726128664019802903779"
+ "9514183602981511756283727771403830521483963923935633133642802139091669457927874464075218944.1",
+ chars_format::fixed, 311, errc{}, 0x1.fffffffffffffp+1023},
+
+ // above (1 + 1 - 3 * 2^-53) * 2^1023: incremented last digit
+ {"1797693134862315608353258760581052985162070023416521662616611746258695532672923265745300992879465492467506314"
+ "9033587701752208710592698796290627760473556921329019091915239418047621712533496094635638726128664019802903779"
+ "9514183602981511756283727771403830521483963923935633133642802139091669457927874464075218945",
+ chars_format::fixed, 309, errc{}, 0x1.fffffffffffffp+1023},
+
+ // VSO-852024 also affected hexfloats.
+ {"0.00000000000008p-1022", chars_format::hex, 22, errc::result_out_of_range, 0x0.0000000000000p+0},
+ {"0."
+ "0000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000001p-1022",
+ chars_format::hex, 1023, errc{}, 0x0.0000000000001p-1022},
+
+ {"0.ffffffffffffe8p-1022", chars_format::hex, 22, errc{}, 0x0.ffffffffffffep-1022},
+ {"0."
+ "ffffffffffffe800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000001p-1022",
+ chars_format::hex, 1023, errc{}, 0x0.fffffffffffffp-1022},
+
+ {"1.00000000000008p+0", chars_format::hex, 19, errc{}, 0x1.0000000000000p+0},
+ {"1."
+ "0000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000001p+0",
+ chars_format::hex, 1020, errc{}, 0x1.0000000000001p+0},
+
+ {"1.ffffffffffffe8p+0", chars_format::hex, 19, errc{}, 0x1.ffffffffffffep+0},
+ {"1."
+ "ffffffffffffe800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000001p+0",
+ chars_format::hex, 1020, errc{}, 0x1.fffffffffffffp+0},
+
+ {"1.00000000000008p+1023", chars_format::hex, 22, errc{}, 0x1.0000000000000p+1023},
+ {"1."
+ "0000000000000800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000001p+1023",
+ chars_format::hex, 1023, errc{}, 0x1.0000000000001p+1023},
+
+ {"1.ffffffffffffe8p+1023", chars_format::hex, 22, errc{}, 0x1.ffffffffffffep+1023},
+ {"1."
+ "ffffffffffffe800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000001p+1023",
+ chars_format::hex, 1023, errc{}, 0x1.fffffffffffffp+1023},
+
+ // VSO-733765 "<charconv>: [Feedback] double std::from_chars behavior on exponent out of range"
+ // LWG-3081 "Floating point from_chars API does not distinguish between overflow and underflow"
+ // These test cases exercise every overflow/underflow codepath.
+ {"1e+1000", chars_format::scientific, 7, errc::result_out_of_range, double_inf},
+ {"1e-1000", chars_format::scientific, 7, errc::result_out_of_range, 0.0},
+ {"1.fffffffffffff8p+1023", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+ {"1e+2000", chars_format::scientific, 7, errc::result_out_of_range, double_inf},
+ {"1e-2000", chars_format::scientific, 7, errc::result_out_of_range, 0.0},
+ {"1e+9999", chars_format::scientific, 7, errc::result_out_of_range, double_inf},
+ {"1e-9999", chars_format::scientific, 7, errc::result_out_of_range, 0.0},
+ {"10e+5199", chars_format::scientific, 8, errc::result_out_of_range, double_inf},
+ {"0.001e-5199", chars_format::scientific, 11, errc::result_out_of_range, 0.0},
+
+ // GH-931 "<charconv>: hex from_chars(\"0.fffffffffffff8p-1022\") is incorrect"
+ // Test cases for values close to std::numeric_limits<double>::min() and std::numeric_limits<double>::max()
+ {"0.fffffffffffffp-1022", chars_format::hex, 21, errc{}, 0x0.fffffffffffffp-1022},
+ {"1.0000000000000p-1022", chars_format::hex, 21, errc{}, 0x1.0000000000000p-1022},
+
+ {"1.ffffffffffffep-1023", chars_format::hex, 21, errc{}, 0x0.fffffffffffffp-1022},
+ {"1.fffffffffffffp-1023", chars_format::hex, 21, errc{}, 0x1.0000000000000p-1022},
+ {"2.0000000000000p-1023", chars_format::hex, 21, errc{}, 0x1.0000000000000p-1022},
+
+ {"3.ffffffffffffcp-1024", chars_format::hex, 21, errc{}, 0x0.fffffffffffffp-1022},
+ {"3.ffffffffffffdp-1024", chars_format::hex, 21, errc{}, 0x0.fffffffffffffp-1022},
+ {"3.ffffffffffffep-1024", chars_format::hex, 21, errc{}, 0x1.0000000000000p-1022},
+ {"3.fffffffffffffp-1024", chars_format::hex, 21, errc{}, 0x1.0000000000000p-1022},
+ {"4.0000000000000p-1024", chars_format::hex, 21, errc{}, 0x1.0000000000000p-1022},
+
+ {"7.ffffffffffff8p-1025", chars_format::hex, 21, errc{}, 0x0.fffffffffffffp-1022},
+ {"7.ffffffffffff9p-1025", chars_format::hex, 21, errc{}, 0x0.fffffffffffffp-1022},
+ {"7.ffffffffffffbp-1025", chars_format::hex, 21, errc{}, 0x0.fffffffffffffp-1022},
+ {"7.ffffffffffffcp-1025", chars_format::hex, 21, errc{}, 0x1.0000000000000p-1022},
+ {"7.ffffffffffffdp-1025", chars_format::hex, 21, errc{}, 0x1.0000000000000p-1022},
+ {"7.ffffffffffffep-1025", chars_format::hex, 21, errc{}, 0x1.0000000000000p-1022},
+ {"7.fffffffffffffp-1025", chars_format::hex, 21, errc{}, 0x1.0000000000000p-1022},
+ {"8.0000000000000p-1025", chars_format::hex, 21, errc{}, 0x1.0000000000000p-1022},
+
+ {"0.fffffffffffff0p-1022", chars_format::hex, 22, errc{}, 0x0.fffffffffffffp-1022},
+ {"0.fffffffffffff1p-1022", chars_format::hex, 22, errc{}, 0x0.fffffffffffffp-1022},
+ {"0.fffffffffffff7p-1022", chars_format::hex, 22, errc{}, 0x0.fffffffffffffp-1022},
+ {"0.fffffffffffff8p-1022", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"0.fffffffffffff9p-1022", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"0.fffffffffffffbp-1022", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"0.fffffffffffffcp-1022", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"0.fffffffffffffdp-1022", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"0.ffffffffffffffp-1022", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"1.00000000000000p-1022", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+
+ {"1.ffffffffffffe0p-1023", chars_format::hex, 22, errc{}, 0x0.fffffffffffffp-1022},
+ {"1.ffffffffffffe1p-1023", chars_format::hex, 22, errc{}, 0x0.fffffffffffffp-1022},
+ {"1.ffffffffffffefp-1023", chars_format::hex, 22, errc{}, 0x0.fffffffffffffp-1022},
+ {"1.fffffffffffff0p-1023", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"1.fffffffffffff1p-1023", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"1.fffffffffffff7p-1023", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"1.fffffffffffff8p-1023", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"1.fffffffffffff9p-1023", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"1.ffffffffffffffp-1023", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"2.00000000000000p-1023", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+
+ {"3.ffffffffffffc0p-1024", chars_format::hex, 22, errc{}, 0x0.fffffffffffffp-1022},
+ {"3.ffffffffffffc1p-1024", chars_format::hex, 22, errc{}, 0x0.fffffffffffffp-1022},
+ {"3.ffffffffffffdfp-1024", chars_format::hex, 22, errc{}, 0x0.fffffffffffffp-1022},
+ {"3.ffffffffffffe0p-1024", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"3.ffffffffffffe1p-1024", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"3.ffffffffffffefp-1024", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"3.fffffffffffff0p-1024", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"3.fffffffffffff1p-1024", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"3.ffffffffffffffp-1024", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"4.00000000000000p-1024", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+
+ {"7.ffffffffffff80p-1025", chars_format::hex, 22, errc{}, 0x0.fffffffffffffp-1022},
+ {"7.ffffffffffff81p-1025", chars_format::hex, 22, errc{}, 0x0.fffffffffffffp-1022},
+ {"7.ffffffffffffbfp-1025", chars_format::hex, 22, errc{}, 0x0.fffffffffffffp-1022},
+ {"7.ffffffffffffc0p-1025", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"7.ffffffffffffc1p-1025", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"7.ffffffffffffdfp-1025", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"7.ffffffffffffe0p-1025", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"7.ffffffffffffe1p-1025", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"7.ffffffffffffffp-1025", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+ {"8.00000000000000p-1025", chars_format::hex, 22, errc{}, 0x1.0000000000000p-1022},
+
+ {"1.fffffffffffffp+1023", chars_format::hex, 21, errc{}, 0x1.fffffffffffffp+1023},
+ {"2.0000000000000p+1023", chars_format::hex, 21, errc::result_out_of_range, double_inf},
+
+ {"3.ffffffffffffep+1022", chars_format::hex, 21, errc{}, 0x1.fffffffffffffp+1023},
+ {"3.fffffffffffffp+1022", chars_format::hex, 21, errc::result_out_of_range, double_inf},
+ {"4.0000000000000p+1022", chars_format::hex, 21, errc::result_out_of_range, double_inf},
+
+ {"7.ffffffffffffcp+1021", chars_format::hex, 21, errc{}, 0x1.fffffffffffffp+1023},
+ {"7.ffffffffffffdp+1021", chars_format::hex, 21, errc{}, 0x1.fffffffffffffp+1023},
+ {"7.ffffffffffffep+1021", chars_format::hex, 21, errc::result_out_of_range, double_inf},
+ {"7.fffffffffffffp+1021", chars_format::hex, 21, errc::result_out_of_range, double_inf},
+ {"8.0000000000000p+1021", chars_format::hex, 21, errc::result_out_of_range, double_inf},
+
+ {"0.fffffffffffff8p+1024", chars_format::hex, 22, errc{}, 0x1.fffffffffffffp+1023},
+ {"0.fffffffffffff9p+1024", chars_format::hex, 22, errc{}, 0x1.fffffffffffffp+1023},
+ {"0.fffffffffffffbp+1024", chars_format::hex, 22, errc{}, 0x1.fffffffffffffp+1023},
+ {"0.fffffffffffffcp+1024", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+ {"0.fffffffffffffdp+1024", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+ {"0.ffffffffffffffp+1024", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+ {"1.00000000000000p+1024", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+
+ {"1.fffffffffffff0p+1023", chars_format::hex, 22, errc{}, 0x1.fffffffffffffp+1023},
+ {"1.fffffffffffff1p+1023", chars_format::hex, 22, errc{}, 0x1.fffffffffffffp+1023},
+ {"1.fffffffffffff7p+1023", chars_format::hex, 22, errc{}, 0x1.fffffffffffffp+1023},
+ {"1.fffffffffffff8p+1023", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+ {"1.fffffffffffff9p+1023", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+ {"1.ffffffffffffffp+1023", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+ {"2.00000000000000p+1023", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+
+ {"3.ffffffffffffe0p+1022", chars_format::hex, 22, errc{}, 0x1.fffffffffffffp+1023},
+ {"3.ffffffffffffe1p+1022", chars_format::hex, 22, errc{}, 0x1.fffffffffffffp+1023},
+ {"3.ffffffffffffefp+1022", chars_format::hex, 22, errc{}, 0x1.fffffffffffffp+1023},
+ {"3.fffffffffffff0p+1022", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+ {"3.fffffffffffff1p+1022", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+ {"3.ffffffffffffffp+1022", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+ {"4.00000000000000p+1022", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+
+ {"7.ffffffffffffc0p+1021", chars_format::hex, 22, errc{}, 0x1.fffffffffffffp+1023},
+ {"7.ffffffffffffc1p+1021", chars_format::hex, 22, errc{}, 0x1.fffffffffffffp+1023},
+ {"7.ffffffffffffdfp+1021", chars_format::hex, 22, errc{}, 0x1.fffffffffffffp+1023},
+ {"7.ffffffffffffe0p+1021", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+ {"7.ffffffffffffe1p+1021", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+ {"7.ffffffffffffffp+1021", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+ {"8.00000000000000p+1021", chars_format::hex, 22, errc::result_out_of_range, double_inf},
+
+ {"0.fffffffffffff80p+1024", chars_format::hex, 23, errc{}, 0x1.fffffffffffffp+1023},
+ {"0.fffffffffffff81p+1024", chars_format::hex, 23, errc{}, 0x1.fffffffffffffp+1023},
+ {"0.fffffffffffffbfp+1024", chars_format::hex, 23, errc{}, 0x1.fffffffffffffp+1023},
+ {"0.fffffffffffffc0p+1024", chars_format::hex, 23, errc::result_out_of_range, double_inf},
+ {"0.fffffffffffffc1p+1024", chars_format::hex, 23, errc::result_out_of_range, double_inf},
+ {"0.fffffffffffffffp+1024", chars_format::hex, 23, errc::result_out_of_range, double_inf},
+ {"1.000000000000000p+1024", chars_format::hex, 23, errc::result_out_of_range, double_inf},
+
+ // (0 + 1 - 2 * 2^-53) * 2^-1022 exactly
+ {"2."
+ "22507385850720088902458687608585988765042311224095946549352480256244000922823569517877588880375915526423097809504"
+ "34312085877387158357291821993020294379224223559819827501242041788969571311791082261043971979604000454897391938079"
+ "19893608152561311337614984204327175103362739154978273159414382813627511383860409424946494228631669542910508020181"
+ "59266421349966065178030950759130587198464239060686371020051087232827846788436319445158661350412234790147923695852"
+ "08321597621066375401613736583044193603714778355306682834535634005074073040135602968046375918583163124224521599262"
+ "54649430083685186171942241764645513713542013221703137049658321015465406803539741790602258950302350193751977303094"
+ "5763173210852507299305089761582519159720757232455434770912461317493580281734466552734375e-308",
+ chars_format::scientific, 773, errc{}, 0x0.fffffffffffffp-1022},
+
+ // (0 + 1 - 2 * 2^-53) * 2^-1022 exactly, followed by a thousand 0 digits
+ {"2."
+ "22507385850720088902458687608585988765042311224095946549352480256244000922823569517877588880375915526423097809504"
+ "34312085877387158357291821993020294379224223559819827501242041788969571311791082261043971979604000454897391938079"
+ "19893608152561311337614984204327175103362739154978273159414382813627511383860409424946494228631669542910508020181"
+ "59266421349966065178030950759130587198464239060686371020051087232827846788436319445158661350412234790147923695852"
+ "08321597621066375401613736583044193603714778355306682834535634005074073040135602968046375918583163124224521599262"
+ "54649430083685186171942241764645513713542013221703137049658321015465406803539741790602258950302350193751977303094"
+ "57631732108525072993050897615825191597207572324554347709124613174935802817344665527343750000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000e-308",
+ chars_format::scientific, 1773, errc{}, 0x0.fffffffffffffp-1022},
+
+ // above (0 + 1 - 2 * 2^-53) * 2^-1022, appended a thousand 0 digits followed by a 1 digit
+ {"2."
+ "22507385850720088902458687608585988765042311224095946549352480256244000922823569517877588880375915526423097809504"
+ "34312085877387158357291821993020294379224223559819827501242041788969571311791082261043971979604000454897391938079"
+ "19893608152561311337614984204327175103362739154978273159414382813627511383860409424946494228631669542910508020181"
+ "59266421349966065178030950759130587198464239060686371020051087232827846788436319445158661350412234790147923695852"
+ "08321597621066375401613736583044193603714778355306682834535634005074073040135602968046375918583163124224521599262"
+ "54649430083685186171942241764645513713542013221703137049658321015465406803539741790602258950302350193751977303094"
+ "57631732108525072993050897615825191597207572324554347709124613174935802817344665527343750000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "000000000000000000000000000000000000000000000000000000000000000000000001e-308",
+ chars_format::scientific, 1774, errc{}, 0x0.fffffffffffffp-1022},
+
+ // above (0 + 1 - 2 * 2^-53) * 2^-1022: appended a 1 digit
+ {"2."
+ "22507385850720088902458687608585988765042311224095946549352480256244000922823569517877588880375915526423097809504"
+ "34312085877387158357291821993020294379224223559819827501242041788969571311791082261043971979604000454897391938079"
+ "19893608152561311337614984204327175103362739154978273159414382813627511383860409424946494228631669542910508020181"
+ "59266421349966065178030950759130587198464239060686371020051087232827846788436319445158661350412234790147923695852"
+ "08321597621066375401613736583044193603714778355306682834535634005074073040135602968046375918583163124224521599262"
+ "54649430083685186171942241764645513713542013221703137049658321015465406803539741790602258950302350193751977303094"
+ "57631732108525072993050897615825191597207572324554347709124613174935802817344665527343751e-308",
+ chars_format::scientific, 774, errc{}, 0x0.fffffffffffffp-1022},
+
+ // above (0 + 1 - 2 * 2^-53) * 2^-1022: incremented last digit
+ {"2."
+ "22507385850720088902458687608585988765042311224095946549352480256244000922823569517877588880375915526423097809504"
+ "34312085877387158357291821993020294379224223559819827501242041788969571311791082261043971979604000454897391938079"
+ "19893608152561311337614984204327175103362739154978273159414382813627511383860409424946494228631669542910508020181"
+ "59266421349966065178030950759130587198464239060686371020051087232827846788436319445158661350412234790147923695852"
+ "08321597621066375401613736583044193603714778355306682834535634005074073040135602968046375918583163124224521599262"
+ "54649430083685186171942241764645513713542013221703137049658321015465406803539741790602258950302350193751977303094"
+ "5763173210852507299305089761582519159720757232455434770912461317493580281734466552734376e-308",
+ chars_format::scientific, 773, errc{}, 0x0.fffffffffffffp-1022},
+
+ // below (0 + 1 - 2^-53) * 2^-1022: decremented last digit, then appended three 9 digits
+ {"2."
+ "22507385850720113605740979670913197593481954635164564802342610972482222202107694551652952390813508791414915891303"
+ "96211068700864386945946455276572074078206217433799881410632673292535522868813721490129811224514518898490572223072"
+ "85255133155755015914397476397983411801999323962548289017107081850690630666655994938275772572015763062690663332647"
+ "56530000924588831643303777979186961204949739037782970490505108060994073026293712895895000358379996720725430436028"
+ "40788957717961509455167482434710307026091446215722898802581825451803257070188608721131280795122334262883686223215"
+ "03775666622503982534335974568884423900265498198385487948292206894721689831099698365846814022854243330660339850886"
+ "44580400103493397042756718644338377048603786162277173854562306587467901408672332763671874999e-308",
+ chars_format::scientific, 777, errc{}, 0x0.fffffffffffffp-1022},
+
+ // (0 + 1 - 2^-53) * 2^-1022 exactly
+ {"2."
+ "22507385850720113605740979670913197593481954635164564802342610972482222202107694551652952390813508791414915891303"
+ "96211068700864386945946455276572074078206217433799881410632673292535522868813721490129811224514518898490572223072"
+ "85255133155755015914397476397983411801999323962548289017107081850690630666655994938275772572015763062690663332647"
+ "56530000924588831643303777979186961204949739037782970490505108060994073026293712895895000358379996720725430436028"
+ "40788957717961509455167482434710307026091446215722898802581825451803257070188608721131280795122334262883686223215"
+ "03775666622503982534335974568884423900265498198385487948292206894721689831099698365846814022854243330660339850886"
+ "44580400103493397042756718644338377048603786162277173854562306587467901408672332763671875e-308",
+ chars_format::scientific, 774, errc{}, 0x1.0000000000000p-1022},
+
+ // (0 + 1 - 2^-53) * 2^-1022 exactly, followed by a thousand 0 digits
+ {"2."
+ "22507385850720113605740979670913197593481954635164564802342610972482222202107694551652952390813508791414915891303"
+ "96211068700864386945946455276572074078206217433799881410632673292535522868813721490129811224514518898490572223072"
+ "85255133155755015914397476397983411801999323962548289017107081850690630666655994938275772572015763062690663332647"
+ "56530000924588831643303777979186961204949739037782970490505108060994073026293712895895000358379996720725430436028"
+ "40788957717961509455167482434710307026091446215722898802581825451803257070188608721131280795122334262883686223215"
+ "03775666622503982534335974568884423900265498198385487948292206894721689831099698365846814022854243330660339850886"
+ "44580400103493397042756718644338377048603786162277173854562306587467901408672332763671875000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "000000000000000000000000000000000000000000000000000000000000000000000000e-308",
+ chars_format::scientific, 1774, errc{}, 0x1.0000000000000p-1022},
+
+ // above (0 + 1 - 2^-53) * 2^-1022: append a thousand 0 digits followed by a 1 digit
+ {"2."
+ "22507385850720113605740979670913197593481954635164564802342610972482222202107694551652952390813508791414915891303"
+ "96211068700864386945946455276572074078206217433799881410632673292535522868813721490129811224514518898490572223072"
+ "85255133155755015914397476397983411801999323962548289017107081850690630666655994938275772572015763062690663332647"
+ "56530000924588831643303777979186961204949739037782970490505108060994073026293712895895000358379996720725430436028"
+ "40788957717961509455167482434710307026091446215722898802581825451803257070188608721131280795122334262883686223215"
+ "03775666622503982534335974568884423900265498198385487948292206894721689831099698365846814022854243330660339850886"
+ "44580400103493397042756718644338377048603786162277173854562306587467901408672332763671875000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000001e-308",
+ chars_format::scientific, 1775, errc{}, 0x1.0000000000000p-1022},
+
+ // above (0 + 1 - 2^-53) * 2^-1022: appended a 1 digit
+ {"2."
+ "22507385850720113605740979670913197593481954635164564802342610972482222202107694551652952390813508791414915891303"
+ "96211068700864386945946455276572074078206217433799881410632673292535522868813721490129811224514518898490572223072"
+ "85255133155755015914397476397983411801999323962548289017107081850690630666655994938275772572015763062690663332647"
+ "56530000924588831643303777979186961204949739037782970490505108060994073026293712895895000358379996720725430436028"
+ "40788957717961509455167482434710307026091446215722898802581825451803257070188608721131280795122334262883686223215"
+ "03775666622503982534335974568884423900265498198385487948292206894721689831099698365846814022854243330660339850886"
+ "445804001034933970427567186443383770486037861622771738545623065874679014086723327636718751e-308",
+ chars_format::scientific, 775, errc{}, 0x1.0000000000000p-1022},
+
+ // above (0 + 1 - 2^-53) * 2^-1022: incremented last digit
+ {"2."
+ "22507385850720113605740979670913197593481954635164564802342610972482222202107694551652952390813508791414915891303"
+ "96211068700864386945946455276572074078206217433799881410632673292535522868813721490129811224514518898490572223072"
+ "85255133155755015914397476397983411801999323962548289017107081850690630666655994938275772572015763062690663332647"
+ "56530000924588831643303777979186961204949739037782970490505108060994073026293712895895000358379996720725430436028"
+ "40788957717961509455167482434710307026091446215722898802581825451803257070188608721131280795122334262883686223215"
+ "03775666622503982534335974568884423900265498198385487948292206894721689831099698365846814022854243330660339850886"
+ "44580400103493397042756718644338377048603786162277173854562306587467901408672332763671876e-308",
+ chars_format::scientific, 774, errc{}, 0x1.0000000000000p-1022},
+
+ // below (0 + 1 - 0.5 * 2^-53) * 2^-1022: decremented last digit, then appended three 9 digits
+ {"2."
+ "22507385850720125957382125702076802007701776340698873928837676330601332841749757068540634146032305423910824932203"
+ "77160560112603001240273771918347963927697214370789908365327989044318498647325041104672730846969778120287162365569"
+ "67935895657351868202788722494811530151317616366333296945953431369222190308053787694940411743707809822580740988880"
+ "55161790711900214875940191589215148208192489026331270225732118475077186145222409621263169862363877686014183806116"
+ "57022637766409076481944355360543363737279780145931006786604921175167849085215111597673733233391919832213268535191"
+ "28338784891913380715532840971003878993627240686726663397609149834349831344879676653469091559130189899114521124782"
+ "380547341009775590676096291585949697743018930811385869272811532937339507043361663818359374999e-308",
+ chars_format::scientific, 778, errc{}, 0x1.0000000000000p-1022},
+
+ // (0 + 1 - 0.5 * 2^-53) * 2^-1022 exactly
+ {"2."
+ "22507385850720125957382125702076802007701776340698873928837676330601332841749757068540634146032305423910824932203"
+ "77160560112603001240273771918347963927697214370789908365327989044318498647325041104672730846969778120287162365569"
+ "67935895657351868202788722494811530151317616366333296945953431369222190308053787694940411743707809822580740988880"
+ "55161790711900214875940191589215148208192489026331270225732118475077186145222409621263169862363877686014183806116"
+ "57022637766409076481944355360543363737279780145931006786604921175167849085215111597673733233391919832213268535191"
+ "28338784891913380715532840971003878993627240686726663397609149834349831344879676653469091559130189899114521124782"
+ "380547341009775590676096291585949697743018930811385869272811532937339507043361663818359375e-308",
+ chars_format::scientific, 775, errc{}, 0x1.0000000000000p-1022},
+
+ // (0 + 1 - 0.5 * 2^-53) * 2^-1022 exactly, followed by a thousand 0 digits
+ {"2."
+ "22507385850720125957382125702076802007701776340698873928837676330601332841749757068540634146032305423910824932203"
+ "77160560112603001240273771918347963927697214370789908365327989044318498647325041104672730846969778120287162365569"
+ "67935895657351868202788722494811530151317616366333296945953431369222190308053787694940411743707809822580740988880"
+ "55161790711900214875940191589215148208192489026331270225732118475077186145222409621263169862363877686014183806116"
+ "57022637766409076481944355360543363737279780145931006786604921175167849085215111597673733233391919832213268535191"
+ "28338784891913380715532840971003878993627240686726663397609149834349831344879676653469091559130189899114521124782"
+ "38054734100977559067609629158594969774301893081138586927281153293733950704336166381835937500000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000e-308",
+ chars_format::scientific, 1775, errc{}, 0x1.0000000000000p-1022},
+
+ // above (0 + 1 - 0.5 * 2^-53) * 2^-1022: append a thousand 0 digits followed by a 1 digit
+ {"2."
+ "22507385850720125957382125702076802007701776340698873928837676330601332841749757068540634146032305423910824932203"
+ "77160560112603001240273771918347963927697214370789908365327989044318498647325041104672730846969778120287162365569"
+ "67935895657351868202788722494811530151317616366333296945953431369222190308053787694940411743707809822580740988880"
+ "55161790711900214875940191589215148208192489026331270225732118475077186145222409621263169862363877686014183806116"
+ "57022637766409076481944355360543363737279780145931006786604921175167849085215111597673733233391919832213268535191"
+ "28338784891913380715532840971003878993627240686726663397609149834349831344879676653469091559130189899114521124782"
+ "38054734100977559067609629158594969774301893081138586927281153293733950704336166381835937500000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000001e-308",
+ chars_format::scientific, 1776, errc{}, 0x1.0000000000000p-1022},
+
+ // above (0 + 1 - 0.5 * 2^-53) * 2^-1022: appended a 1 digit
+ {"2."
+ "22507385850720125957382125702076802007701776340698873928837676330601332841749757068540634146032305423910824932203"
+ "77160560112603001240273771918347963927697214370789908365327989044318498647325041104672730846969778120287162365569"
+ "67935895657351868202788722494811530151317616366333296945953431369222190308053787694940411743707809822580740988880"
+ "55161790711900214875940191589215148208192489026331270225732118475077186145222409621263169862363877686014183806116"
+ "57022637766409076481944355360543363737279780145931006786604921175167849085215111597673733233391919832213268535191"
+ "28338784891913380715532840971003878993627240686726663397609149834349831344879676653469091559130189899114521124782"
+ "3805473410097755906760962915859496977430189308113858692728115329373395070433616638183593751e-308",
+ chars_format::scientific, 776, errc{}, 0x1.0000000000000p-1022},
+
+ // above (0 + 1 - 0.5 * 2^-53) * 2^-1022: incremented last digit
+ {"2."
+ "22507385850720125957382125702076802007701776340698873928837676330601332841749757068540634146032305423910824932203"
+ "77160560112603001240273771918347963927697214370789908365327989044318498647325041104672730846969778120287162365569"
+ "67935895657351868202788722494811530151317616366333296945953431369222190308053787694940411743707809822580740988880"
+ "55161790711900214875940191589215148208192489026331270225732118475077186145222409621263169862363877686014183806116"
+ "57022637766409076481944355360543363737279780145931006786604921175167849085215111597673733233391919832213268535191"
+ "28338784891913380715532840971003878993627240686726663397609149834349831344879676653469091559130189899114521124782"
+ "380547341009775590676096291585949697743018930811385869272811532937339507043361663818359376e-308",
+ chars_format::scientific, 775, errc{}, 0x1.0000000000000p-1022},
+
+ // below 1 * 2^-1022: decremented last digit, then appended three 9 digits
+ {"2."
+ "22507385850720138309023271733240406421921598046233183055332741688720443481391819585428315901251102056406733973103"
+ "58110051524341615534601088560123853777188211307779935320023304796101474425836360719215650469425037342083752508066"
+ "50616658158948720491179968591639648500635908770118304874799780887753749949451580451605050915399856582470818645113"
+ "53793580499211598108576605199243335211435239014879569960959128889160299264151106346631339366347758651302937176204"
+ "73256317814856643508721228286376420448468114076139114770628016898532441100241614474216185671661505401542850847167"
+ "52901903161322778896729707373123334086988983175067838846926092773977972858659654941091369095406136467568702398678"
+ "315290680984617210924625396728515624999e-308",
+ chars_format::scientific, 724, errc{}, 0x1.0000000000000p-1022},
+
+ // 1 * 2^-1022 exactly
+ {"2."
+ "22507385850720138309023271733240406421921598046233183055332741688720443481391819585428315901251102056406733973103"
+ "58110051524341615534601088560123853777188211307779935320023304796101474425836360719215650469425037342083752508066"
+ "50616658158948720491179968591639648500635908770118304874799780887753749949451580451605050915399856582470818645113"
+ "53793580499211598108576605199243335211435239014879569960959128889160299264151106346631339366347758651302937176204"
+ "73256317814856643508721228286376420448468114076139114770628016898532441100241614474216185671661505401542850847167"
+ "52901903161322778896729707373123334086988983175067838846926092773977972858659654941091369095406136467568702398678"
+ "315290680984617210924625396728515625e-308",
+ chars_format::scientific, 721, errc{}, 0x1.0000000000000p-1022},
+
+ // (1 + 1 - 2 * 2^-53) * 2^1023 exactly
+ {"17976931348623157081452742373170435679807056752584499659891747680315726078002853876058955863276687817154045895351"
+ "43824642343213268894641827684675467035375169860499105765512820762454900903893289440758685084551339423045832369032"
+ "22948165808559332123348274797826204144723168738177180919299881250404026184124858368",
+ chars_format::fixed, 309, errc{}, 0x1.fffffffffffffp+1023},
+
+ // (1 + 1 - 2 * 2^-53) * 2^1023 exactly, followed by a thousand 0 digits
+ {"17976931348623157081452742373170435679807056752584499659891747680315726078002853876058955863276687817154045895351"
+ "43824642343213268894641827684675467035375169860499105765512820762454900903893289440758685084551339423045832369032"
+ "22948165808559332123348274797826204144723168738177180919299881250404026184124858368."
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ chars_format::fixed, 1310, errc{}, 0x1.fffffffffffffp+1023},
+
+ // above (1 + 1 - 2 * 2^-53) * 2^1023, appended a thousand 0 digits followed by a 1 digit
+ {"17976931348623157081452742373170435679807056752584499659891747680315726078002853876058955863276687817154045895351"
+ "43824642343213268894641827684675467035375169860499105765512820762454900903893289440758685084551339423045832369032"
+ "22948165808559332123348274797826204144723168738177180919299881250404026184124858368."
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001",
+ chars_format::fixed, 1311, errc{}, 0x1.fffffffffffffp+1023},
+
+ // above (1 + 1 - 2 * 2^-53) * 2^1023: appended a 1 digit
+ {"17976931348623157081452742373170435679807056752584499659891747680315726078002853876058955863276687817154045895351"
+ "43824642343213268894641827684675467035375169860499105765512820762454900903893289440758685084551339423045832369032"
+ "22948165808559332123348274797826204144723168738177180919299881250404026184124858368.1",
+ chars_format::fixed, 311, errc{}, 0x1.fffffffffffffp+1023},
+
+ // above (1 + 1 - 2 * 2^-53) * 2^1023: incremented last digit
+ {"17976931348623157081452742373170435679807056752584499659891747680315726078002853876058955863276687817154045895351"
+ "43824642343213268894641827684675467035375169860499105765512820762454900903893289440758685084551339423045832369032"
+ "22948165808559332123348274797826204144723168738177180919299881250404026184124858369",
+ chars_format::fixed, 309, errc{}, 0x1.fffffffffffffp+1023},
+
+ // below (1 + 1 - 2^-53) * 2^1023: decremented last digit, then appended three 9 digits
+ {"17976931348623158079372897140530341507993413271003782693617377898044496829276475094664901797758720709633028641669"
+ "28879109465555478519404026306574886715058206819089020007083836762738548458177115317644757302700698555713669596228"
+ "42914819860834936475292719074168444365510704342711559699508093042880177904174497791.999",
+ chars_format::fixed, 313, errc{}, 0x1.fffffffffffffp+1023},
+
+ // (1 + 1 - 2^-53) * 2^1023 exactly
+ {"17976931348623158079372897140530341507993413271003782693617377898044496829276475094664901797758720709633028641669"
+ "28879109465555478519404026306574886715058206819089020007083836762738548458177115317644757302700698555713669596228"
+ "42914819860834936475292719074168444365510704342711559699508093042880177904174497792",
+ chars_format::fixed, 309, errc::result_out_of_range, double_inf},
+
+ // (1 + 1 - 2^-53) * 2^1023 exactly, followed by a thousand 0 digits
+ {"17976931348623158079372897140530341507993413271003782693617377898044496829276475094664901797758720709633028641669"
+ "28879109465555478519404026306574886715058206819089020007083836762738548458177115317644757302700698555713669596228"
+ "42914819860834936475292719074168444365510704342711559699508093042880177904174497792."
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+ chars_format::fixed, 1310, errc::result_out_of_range, double_inf},
+
+ // above (1 + 1 - 2^-53) * 2^1023: append a thousand 0 digits followed by a 1 digit
+ {"17976931348623158079372897140530341507993413271003782693617377898044496829276475094664901797758720709633028641669"
+ "28879109465555478519404026306574886715058206819089020007083836762738548458177115317644757302700698555713669596228"
+ "42914819860834936475292719074168444365510704342711559699508093042880177904174497792."
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+ "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001",
+ chars_format::fixed, 1311, errc::result_out_of_range, double_inf},
+
+ // above (1 + 1 - 2^-53) * 2^1023: appended a 1 digit
+ {"17976931348623158079372897140530341507993413271003782693617377898044496829276475094664901797758720709633028641669"
+ "28879109465555478519404026306574886715058206819089020007083836762738548458177115317644757302700698555713669596228"
+ "42914819860834936475292719074168444365510704342711559699508093042880177904174497792.1",
+ chars_format::fixed, 311, errc::result_out_of_range, double_inf},
+
+ // above (1 + 1 - 2^-53) * 2^1023: incremented last digit
+ {"17976931348623158079372897140530341507993413271003782693617377898044496829276475094664901797758720709633028641669"
+ "28879109465555478519404026306574886715058206819089020007083836762738548458177115317644757302700698555713669596228"
+ "42914819860834936475292719074168444365510704342711559699508093042880177904174497792",
+ chars_format::fixed, 309, errc::result_out_of_range, double_inf},
+
+ // below 1 * 2^1024: decremented last digit, then appended three 9 digits
+ {"17976931348623159077293051907890247336179769789423065727343008115773267580550096313270847732240753602112011387987"
+ "13933576587897688144166224928474306394741243777678934248654852763022196012460941194530829520850057688381506823424"
+ "62881473913110540827237163350510684586298239947245938479716304835356329624224137215.999",
+ chars_format::fixed, 313, errc::result_out_of_range, double_inf},
+
+ // 1 * 2^1024 exactly
+ {"17976931348623159077293051907890247336179769789423065727343008115773267580550096313270847732240753602112011387987"
+ "13933576587897688144166224928474306394741243777678934248654852763022196012460941194530829520850057688381506823424"
+ "62881473913110540827237163350510684586298239947245938479716304835356329624224137216",
+ chars_format::fixed, 309, errc::result_out_of_range, double_inf},
+};
+
+int
+main()
+{
+ for (const auto [input,fmt,correct_end,correct_ec,correct_value]
+ : double_from_chars_test_cases)
+ {
+ double value = -1.2345;
+ const auto [ptr,ec] = from_chars(input, input + strlen(input), value, fmt);
+ VERIFY( correct_ec == ec );
+ VERIFY( ptr == input + correct_end );
+ if (ec == errc{})
+ VERIFY( value == correct_value );
+ else
+ VERIFY( value == -1.2345 );
+ }
+}
diff --git a/libstdc++-v3/testsuite/20_util/from_chars/float.cc b/libstdc++-v3/testsuite/20_util/from_chars/float.cc
new file mode 100644
index 00000000000..13909e4c5d9
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/from_chars/float.cc
@@ -0,0 +1,290 @@
+// This file consists of testcases extracted from the MSVC STL testsuite.
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+// { dg-do run { target c++17 } }
+// { dg-require-effective-target ieee_floats }
+
+#include <charconv>
+
+#include <limits>
+#include <cstring>
+#include <testsuite_hooks.h>
+
+using namespace std;
+
+inline constexpr float float_inf = numeric_limits<float>::infinity();
+
+struct float_to_chars_testcase {
+ const char* input;
+ chars_format fmt;
+ size_t correct_idx;
+ errc correct_ec;
+ float correct_value;
+};
+
+inline constexpr float_to_chars_testcase float_from_chars_test_cases[] = {
+ {"1.a0000400", chars_format::hex, 10, errc{}, 0x1.a00004p0f}, // exact
+ {"1.a0000401", chars_format::hex, 10, errc{}, 0x1.a00004p0f}, // below midpoint, round down
+ {"1.a0000500", chars_format::hex, 10, errc{}, 0x1.a00004p0f}, // midpoint, round down to even
+ {"1.a0000501", chars_format::hex, 10, errc{}, 0x1.a00006p0f}, // above midpoint, round up
+ {"1.a0000600", chars_format::hex, 10, errc{}, 0x1.a00006p0f}, // exact
+ {"1.a0000601", chars_format::hex, 10, errc{}, 0x1.a00006p0f}, // below midpoint, round down
+ {"1.a0000700", chars_format::hex, 10, errc{}, 0x1.a00008p0f}, // midpoint, round up to even
+ {"1.a0000701", chars_format::hex, 10, errc{}, 0x1.a00008p0f}, // above midpoint, round up
+
+ {"1.0000040", chars_format::hex, 9, errc{}, 0x1.000004p0f}, // exact
+ {"1.0000041", chars_format::hex, 9, errc{}, 0x1.000004p0f}, // below midpoint, round down
+ {"1.0000050", chars_format::hex, 9, errc{}, 0x1.000004p0f}, // midpoint, round down to even
+ {"1.0000051", chars_format::hex, 9, errc{}, 0x1.000006p0f}, // above midpoint, round up
+ {"1.0000060", chars_format::hex, 9, errc{}, 0x1.000006p0f}, // exact
+ {"1.0000061", chars_format::hex, 9, errc{}, 0x1.000006p0f}, // below midpoint, round down
+ {"1.0000070", chars_format::hex, 9, errc{}, 0x1.000008p0f}, // midpoint, round up to even
+ {"1.0000071", chars_format::hex, 9, errc{}, 0x1.000008p0f}, // above midpoint, round up
+
+ {"1.0000002384185791015625000000", chars_format::general, 30, errc{}, 0x1.000004p0f}, // exact
+ {"1.0000002421438694000244140625", chars_format::general, 30, errc{}, 0x1.000004p0f}, // below midpoint, round down
+ {"1.0000002980232238769531249999", chars_format::general, 30, errc{}, 0x1.000004p0f}, // below midpoint, round down
+ {"1.0000002980232238769531250000", chars_format::general, 30, errc{},
+ 0x1.000004p0f}, // midpoint, round down to even
+ {"1.0000002980232238769531250001", chars_format::general, 30, errc{}, 0x1.000006p0f}, // above midpoint, round up
+ {"1.0000003017485141754150390625", chars_format::general, 30, errc{}, 0x1.000006p0f}, // above midpoint, round up
+ {"1.0000003576278686523437500000", chars_format::general, 30, errc{}, 0x1.000006p0f}, // exact
+ {"1.0000003613531589508056640625", chars_format::general, 30, errc{}, 0x1.000006p0f}, // below midpoint, round down
+ {"1.0000004172325134277343749999", chars_format::general, 30, errc{}, 0x1.000006p0f}, // below midpoint, round down
+ {"1.0000004172325134277343750000", chars_format::general, 30, errc{}, 0x1.000008p0f}, // midpoint, round up to even
+ {"1.0000004172325134277343750001", chars_format::general, 30, errc{}, 0x1.000008p0f}, // above midpoint, round up
+ {"1.0000004209578037261962890625", chars_format::general, 30, errc{}, 0x1.000008p0f}, // above midpoint, round up
+
+ // VSO-838635 "<charconv>: from_chars() mishandles certain subnormals"
+ // This bug didn't actually affect float, but we should have similar test cases.
+ // These values change on half-ulp boundaries:
+ // 1 * 2^-150 ~= 7.01e-46 (half-ulp between zero and min subnormal)
+ // 2 * 2^-150 ~= 1.40e-45 (min subnormal)
+ // 3 * 2^-150 ~= 2.10e-45 (half-ulp between min subnormal and next subnormal)
+ // 4 * 2^-150 ~= 2.80e-45 (next subnormal)
+ {"6."
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666"
+ "6666666666666666666e-46",
+ chars_format::scientific, 1006, errc::result_out_of_range, 0x0.000000p+0f},
+ {"7."
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777"
+ "7777777777777777777e-46",
+ chars_format::scientific, 1006, errc{}, 0x0.000002p-126f},
+ {"8."
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888"
+ "8888888888888888888e-46",
+ chars_format::scientific, 1006, errc{}, 0x0.000002p-126f},
+ {"9."
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
+ "9999999999999999999e-46",
+ chars_format::scientific, 1006, errc{}, 0x0.000002p-126f},
+ {"1."
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
+ "1111111111111111111e-45",
+ chars_format::scientific, 1006, errc{}, 0x0.000002p-126f},
+ {"2."
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222"
+ "2222222222222222222e-45",
+ chars_format::scientific, 1006, errc{}, 0x0.000004p-126f},
+
+ // VSO-733765 "<charconv>: [Feedback] double std::from_chars behavior on exponent out of range"
+ // LWG-3081 "Floating point from_chars API does not distinguish between overflow and underflow"
+ // These test cases exercise every overflow/underflow codepath.
+ {"1e+1000", chars_format::scientific, 7, errc::result_out_of_range, float_inf},
+ {"1e-1000", chars_format::scientific, 7, errc::result_out_of_range, 0.0f},
+ {"1.ffffffp+127", chars_format::hex, 13, errc::result_out_of_range, float_inf},
+ {"1e+2000", chars_format::scientific, 7, errc::result_out_of_range, float_inf},
+ {"1e-2000", chars_format::scientific, 7, errc::result_out_of_range, 0.0f},
+ {"1e+9999", chars_format::scientific, 7, errc::result_out_of_range, float_inf},
+ {"1e-9999", chars_format::scientific, 7, errc::result_out_of_range, 0.0f},
+ {"10e+5199", chars_format::scientific, 8, errc::result_out_of_range, float_inf},
+ {"0.001e-5199", chars_format::scientific, 11, errc::result_out_of_range, 0.0f},
+
+ // GH-931 "<charconv>: hex from_chars(\"0.fffffffffffff8p-1022\") is incorrect"
+ // Test cases for values close to std::numeric_limits<float>::min() and std::numeric_limits<float>::max()
+ {"7.fffffp-129", chars_format::hex, 12, errc{}, 0x0.fffffep-126f},
+ {"8.00000p-129", chars_format::hex, 12, errc{}, 0x1.000000p-126f},
+
+ {"0.fffffep-126", chars_format::hex, 13, errc{}, 0x0.fffffep-126f},
+ {"0.ffffffp-126", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+ {"1.000000p-126", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+
+ {"1.fffffcp-127", chars_format::hex, 13, errc{}, 0x0.fffffep-126f},
+ {"1.fffffdp-127", chars_format::hex, 13, errc{}, 0x0.fffffep-126f},
+ {"1.fffffep-127", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+ {"1.ffffffp-127", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+ {"2.000000p-127", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+
+ {"3.fffff8p-128", chars_format::hex, 13, errc{}, 0x0.fffffep-126f},
+ {"3.fffff9p-128", chars_format::hex, 13, errc{}, 0x0.fffffep-126f},
+ {"3.fffffbp-128", chars_format::hex, 13, errc{}, 0x0.fffffep-126f},
+ {"3.fffffcp-128", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+ {"3.fffffdp-128", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+ {"3.fffffep-128", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+ {"3.ffffffp-128", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+ {"4.000000p-128", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+
+ {"7.fffff0p-129", chars_format::hex, 13, errc{}, 0x0.fffffep-126f},
+ {"7.fffff1p-129", chars_format::hex, 13, errc{}, 0x0.fffffep-126f},
+ {"7.fffff7p-129", chars_format::hex, 13, errc{}, 0x0.fffffep-126f},
+ {"7.fffff8p-129", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+ {"7.fffff9p-129", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+ {"7.fffffbp-129", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+ {"7.fffffcp-129", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+ {"7.fffffdp-129", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+ {"7.ffffffp-129", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+ {"8.000000p-129", chars_format::hex, 13, errc{}, 0x1.000000p-126f},
+
+ {"0.fffffe0p-126", chars_format::hex, 14, errc{}, 0x0.fffffep-126f},
+ {"0.fffffe1p-126", chars_format::hex, 14, errc{}, 0x0.fffffep-126f},
+ {"0.fffffefp-126", chars_format::hex, 14, errc{}, 0x0.fffffep-126f},
+ {"0.ffffff0p-126", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"0.ffffff1p-126", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"0.ffffff7p-126", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"0.ffffff8p-126", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"0.ffffff9p-126", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"0.fffffffp-126", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"1.0000000p-126", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+
+ {"1.fffffc0p-127", chars_format::hex, 14, errc{}, 0x0.fffffep-126f},
+ {"1.fffffc1p-127", chars_format::hex, 14, errc{}, 0x0.fffffep-126f},
+ {"1.fffffdfp-127", chars_format::hex, 14, errc{}, 0x0.fffffep-126f},
+ {"1.fffffe0p-127", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"1.fffffe1p-127", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"1.fffffefp-127", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"1.ffffff0p-127", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"1.ffffff1p-127", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"1.fffffffp-127", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"2.0000000p-127", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+
+ {"3.fffff80p-128", chars_format::hex, 14, errc{}, 0x0.fffffep-126f},
+ {"3.fffff81p-128", chars_format::hex, 14, errc{}, 0x0.fffffep-126f},
+ {"3.fffffbfp-128", chars_format::hex, 14, errc{}, 0x0.fffffep-126f},
+ {"3.fffffc0p-128", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"3.fffffc1p-128", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"3.fffffdfp-128", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"3.fffffe0p-128", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"3.fffffe1p-128", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"3.fffffffp-128", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+ {"4.0000000p-128", chars_format::hex, 14, errc{}, 0x1.000000p-126f},
+
+ {"0.ffffffp+128", chars_format::hex, 13, errc{}, 0x1.fffffep+127f},
+ {"1.000000p+128", chars_format::hex, 13, errc::result_out_of_range, float_inf},
+
+ {"1.fffffep+127", chars_format::hex, 13, errc{}, 0x1.fffffep+127f},
+ {"1.ffffffp+127", chars_format::hex, 13, errc::result_out_of_range, float_inf},
+ {"2.000000p+127", chars_format::hex, 13, errc::result_out_of_range, float_inf},
+
+ {"3.fffffcp+126", chars_format::hex, 13, errc{}, 0x1.fffffep+127f},
+ {"3.fffffdp+126", chars_format::hex, 13, errc{}, 0x1.fffffep+127f},
+ {"3.fffffep+126", chars_format::hex, 13, errc::result_out_of_range, float_inf},
+ {"3.ffffffp+126", chars_format::hex, 13, errc::result_out_of_range, float_inf},
+ {"4.000000p+126", chars_format::hex, 13, errc::result_out_of_range, float_inf},
+
+ {"7.fffff8p+125", chars_format::hex, 13, errc{}, 0x1.fffffep+127f},
+ {"7.fffff9p+125", chars_format::hex, 13, errc{}, 0x1.fffffep+127f},
+ {"7.fffffbp+125", chars_format::hex, 13, errc{}, 0x1.fffffep+127f},
+ {"7.fffffcp+125", chars_format::hex, 13, errc::result_out_of_range, float_inf},
+ {"7.fffffdp+125", chars_format::hex, 13, errc::result_out_of_range, float_inf},
+ {"7.ffffffp+125", chars_format::hex, 13, errc::result_out_of_range, float_inf},
+ {"8.000000p+125", chars_format::hex, 13, errc::result_out_of_range, float_inf},
+
+ {"0.ffffff0p+128", chars_format::hex, 14, errc{}, 0x1.fffffep+127f},
+ {"0.ffffff1p+128", chars_format::hex, 14, errc{}, 0x1.fffffep+127f},
+ {"0.ffffff7p+128", chars_format::hex, 14, errc{}, 0x1.fffffep+127f},
+ {"0.ffffff8p+128", chars_format::hex, 14, errc::result_out_of_range, float_inf},
+ {"0.ffffff9p+128", chars_format::hex, 14, errc::result_out_of_range, float_inf},
+ {"0.fffffffp+128", chars_format::hex, 14, errc::result_out_of_range, float_inf},
+ {"1.0000000p+128", chars_format::hex, 14, errc::result_out_of_range, float_inf},
+
+ {"1.fffffe0p+127", chars_format::hex, 14, errc{}, 0x1.fffffep+127f},
+ {"1.fffffe1p+127", chars_format::hex, 14, errc{}, 0x1.fffffep+127f},
+ {"1.fffffefp+127", chars_format::hex, 14, errc{}, 0x1.fffffep+127f},
+ {"1.ffffff0p+127", chars_format::hex, 14, errc::result_out_of_range, float_inf},
+ {"1.ffffff1p+127", chars_format::hex, 14, errc::result_out_of_range, float_inf},
+ {"1.fffffffp+127", chars_format::hex, 14, errc::result_out_of_range, float_inf},
+ {"2.0000000p+127", chars_format::hex, 14, errc::result_out_of_range, float_inf},
+
+ {"3.fffffc0p+126", chars_format::hex, 14, errc{}, 0x1.fffffep+127f},
+ {"3.fffffc1p+126", chars_format::hex, 14, errc{}, 0x1.fffffep+127f},
+ {"3.fffffdfp+126", chars_format::hex, 14, errc{}, 0x1.fffffep+127f},
+ {"3.fffffe0p+126", chars_format::hex, 14, errc::result_out_of_range, float_inf},
+ {"3.fffffe1p+126", chars_format::hex, 14, errc::result_out_of_range, float_inf},
+ {"3.fffffffp+126", chars_format::hex, 14, errc::result_out_of_range, float_inf},
+ {"4.0000000p+126", chars_format::hex, 14, errc::result_out_of_range, float_inf},
+
+ {"7.fffff80p+125", chars_format::hex, 14, errc{}, 0x1.fffffep+127f},
+ {"7.fffff81p+125", chars_format::hex, 14, errc{}, 0x1.fffffep+127f},
+ {"7.fffffbfp+125", chars_format::hex, 14, errc{}, 0x1.fffffep+127f},
+ {"7.fffffc0p+125", chars_format::hex, 14, errc::result_out_of_range, float_inf},
+ {"7.fffffc1p+125", chars_format::hex, 14, errc::result_out_of_range, float_inf},
+ {"7.fffffffp+125", chars_format::hex, 14, errc::result_out_of_range, float_inf},
+ {"8.0000000p+125", chars_format::hex, 14, errc::result_out_of_range, float_inf},
+};
+
+int
+main()
+{
+ for (const auto [input,fmt,correct_end,correct_ec,correct_value]
+ : float_from_chars_test_cases)
+ {
+ float value = -1.2345f;
+ const auto [ptr,ec] = from_chars(input, input + strlen(input), value, fmt);
+ VERIFY( correct_ec == ec );
+ VERIFY( ptr == input + correct_end );
+ if (ec == errc{})
+ VERIFY( value == correct_value );
+ else
+ VERIFY( value == -1.2345f );
+ }
+}
--
2.35.0.rc1
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH 1/6 v2] libstdc++: Directly implement hexfloat std::from_chars for binary32/64
2022-01-16 18:06 [PATCH 1/6 v2] libstdc++: Directly implement hexfloat std::from_chars for binary32/64 Patrick Palka
` (4 preceding siblings ...)
2022-01-16 18:06 ` [PATCH 6/6] libstdc++: Import MSVC floating-point std::from_chars testcases Patrick Palka
@ 2022-01-17 10:34 ` Jonathan Wakely
5 siblings, 0 replies; 15+ messages in thread
From: Jonathan Wakely @ 2022-01-17 10:34 UTC (permalink / raw)
To: Patrick Palka; +Cc: gcc Patches, libstdc++
On Sun, 16 Jan 2022 at 18:07, Patrick Palka via Libstdc++ <
libstdc++@gcc.gnu.org> wrote:
> Series tested on x86_64, i686, ppc64, ppc64le, aarch64, does it look OK for
> trunk?
>
OK, thanks.
> libstdc++-v3/ChangeLog:
>
> * src/c++17/floating_from_chars.cc: Include <bit>.
> (ascii_to_hexit, starts_with_ci): Define.
> (__floating_from_chars_hex): Define.
> (from_chars): Conditionally call __floating_from_chars_hex.
> (testsuite/20_util/from_chars/7.cc): New test.
> ---
> libstdc++-v3/src/c++17/floating_from_chars.cc | 376 ++++++++++++++++++
> .../testsuite/20_util/from_chars/7.cc | 151 +++++++
> 2 files changed, 527 insertions(+)
> create mode 100644 libstdc++-v3/testsuite/20_util/from_chars/7.cc
>
> diff --git a/libstdc++-v3/src/c++17/floating_from_chars.cc
> b/libstdc++-v3/src/c++17/floating_from_chars.cc
> index 479e042bb5f..b186da9a955 100644
> --- a/libstdc++-v3/src/c++17/floating_from_chars.cc
> +++ b/libstdc++-v3/src/c++17/floating_from_chars.cc
> @@ -31,6 +31,7 @@
> #define _GLIBCXX_USE_CXX11_ABI 1
>
> #include <charconv>
> +#include <bit>
> #include <string>
> #include <memory_resource>
> #include <cfenv>
> @@ -396,6 +397,371 @@ namespace
> }
> #endif
>
> +#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64
> + // If the given ASCII character represents a hexit, return that hexit.
> + // Otherwise return -1.
> + int
> + ascii_to_hexit(char ch)
> + {
> + if (ch >= '0' && ch <= '9')
> + return ch - '0';
> + if (ch >= 'a' && ch <= 'f')
> + return ch - 'a' + 10;
> + if (ch >= 'A' && ch <= 'F')
> + return ch - 'A' + 10;
> + return -1;
> + }
> +
> + // Return true iff [FIRST,LAST) begins with PREFIX, ignoring case.
> + bool
> + starts_with_ci(const char* first, const char* last, string_view prefix)
> + {
> + __glibcxx_requires_valid_range(first, last);
> +
> + for (char ch : prefix)
> + {
> + __glibcxx_assert(ch >= 'a' && ch <= 'z');
> + if (first == last || (*first != ch && *first != ch - 32))
> + return false;
> + ++first;
> + }
> +
> + return true;
> + }
> +
> + // An implementation of hexadecimal float parsing for binary32/64.
> + template<typename T>
> + from_chars_result
> + __floating_from_chars_hex(const char* first, const char* last, T& value)
> + {
> + static_assert(is_same_v<T, float> || is_same_v<T, double>);
> +
> + using uint_t = conditional_t<is_same_v<T, float>, uint32_t, uint64_t>;
> + constexpr int mantissa_width = is_same_v<T, float> ? 23 : 52;
> + constexpr int exponent_width = is_same_v<T, float> ? 8 : 11;
> + constexpr int exponent_bias = (1 << (exponent_width - 1)) - 1;
> +
> + __glibcxx_requires_valid_range(first, last);
> + if (first == last)
> + return {first, errc::invalid_argument};
> +
> + // Consume the sign bit.
> + const char* const orig_first = first;
> + bool sign_bit = false;
> + if (*first == '-')
> + {
> + sign_bit = true;
> + ++first;
> + }
> +
> + // Handle "inf", "infinity", "NaN" and variants thereof.
> + if (first != last)
> + if (*first == 'i' || *first == 'I' || *first == 'n' || *first ==
> 'N') [[unlikely]]
> + {
> + if (starts_with_ci(first, last, "inf"sv))
> + {
> + first += 3;
> + if (starts_with_ci(first, last, "inity"sv))
> + first += 5;
> +
> + uint_t result = 0;
> + result |= sign_bit;
> + result <<= exponent_width;
> + result |= (1ull << exponent_width) - 1;
> + result <<= mantissa_width;
> + memcpy(&value, &result, sizeof(result));
> +
> + return {first, errc{}};
> + }
> + else if (starts_with_ci(first, last, "nan"))
> + {
> + first += 3;
> +
> + if (first != last && *first == '(')
> + {
> + // Tentatively consume the '(' as we look for an optional
> + // n-char-sequence followed by a ')'.
> + const char* const fallback_first = first;
> + for (;;)
> + {
> + ++first;
> + if (first == last)
> + {
> + first = fallback_first;
> + break;
> + }
> +
> + char ch = *first;
> + if (ch == ')')
> + {
> + ++first;
> + break;
> + }
> + else if ((ch >= '0' && ch <= '9')
> + || (ch >= 'a' && ch <= 'z')
> + || (ch >= 'A' && ch <= 'Z')
> + || ch == '_')
> + continue;
> + else
> + {
> + first = fallback_first;
> + break;
> + }
> + }
> + }
> +
> + // We make the implementation-defined decision of ignoring
> the
> + // sign bit and the n-char-sequence when assembling the NaN.
> + uint_t result = 0;
> + result <<= exponent_width;
> + result |= (1ull << exponent_width) - 1;
> + result <<= mantissa_width;
> + result |= (1ull << (mantissa_width - 1)) | 1;
> + memcpy(&value, &result, sizeof(result));
> +
> + return {first, errc{}};
> + }
> + }
> +
> + // Consume all insignificant leading zeros in the whole part of the
> + // mantissa.
> + bool seen_digit = false;
> + while (first != last && *first == '0')
> + {
> + seen_digit = true;
> + ++first;
> + }
> +
> + // Now consume the rest of the written mantissa, populating MANTISSA
> with the
> + // first MANTISSA_WIDTH+k significant bits of the written mantissa,
> where 1
> + // <= k <= 4 is the bit width of the leading significant written
> hexit.
> + //
> + // Examples:
> + // After parsing "1.2f3", MANTISSA is 0x12f30000000000
> (bit_width=52+1).
> + // After parsing ".0000f0e", MANTISSA is 0xf0e00000000000
> (bit_width=52+4).
> + // After parsing ".1234567890abcd8", MANTISSA is 0x1234567890abcd
> (bit_width=52+1)
> + // and MIDPOINT_BIT is true and NONZERO_TAIL is false.
> + uint_t mantissa = 0;
> + int mantissa_idx = mantissa_width; // The current bit index into
> MANTISSA
> + // into which we'll write the next
> hexit.
> + int exponent_adjustment = 0; // How much we'd have to adjust the
> written
> + // exponent in order to represent the
> mantissa
> + // in scientific form h.hhhhhhhhhhhhh.
> + bool midpoint_bit = false; // Whether the MANTISSA_WIDTH+k+1
> significant
> + // bit is set in the written mantissa.
> + bool nonzero_tail = false; // Whether some bit thereafter is set in
> the
> + // written mantissa.
> + bool seen_decimal_point = false;
> + for (; first != last; ++first)
> + {
> + char ch = *first;
> + if (ch == '.' && !seen_decimal_point)
> + {
> + seen_decimal_point = true;
> + continue;
> + }
> +
> + int hexit = ascii_to_hexit(ch);
> + if (hexit == -1)
> + break;
> + seen_digit = true;
> +
> + if (!seen_decimal_point && mantissa != 0)
> + exponent_adjustment += 4;
> + else if (seen_decimal_point && mantissa == 0)
> + {
> + exponent_adjustment -= 4;
> + if (hexit == 0x0)
> + continue;
> + }
> +
> + if (mantissa_idx >= 0)
> + mantissa |= uint_t(hexit) << mantissa_idx;
> + else if (mantissa_idx >= -4)
> + {
> + if constexpr (is_same_v<T, float>)
> + {
> + __glibcxx_assert(mantissa_idx == -1);
> + mantissa |= hexit >> 1;
> + midpoint_bit = (hexit & 0b0001) != 0;
> + }
> + else
> + {
> + __glibcxx_assert(mantissa_idx == -4);
> + midpoint_bit = (hexit & 0b1000) != 0;
> + nonzero_tail = (hexit & 0b0111) != 0;
> + }
> + }
> + else
> + nonzero_tail |= (hexit != 0x0);
> +
> + mantissa_idx -= 4;
> + }
> + if (mantissa != 0)
> + __glibcxx_assert(__bit_width(mantissa) >= mantissa_width + 1
> + && __bit_width(mantissa) <= mantissa_width + 4);
> + else
> + __glibcxx_assert(!midpoint_bit && !nonzero_tail);
> +
> + if (!seen_digit)
> + {
> + // If we haven't seen any digit at this point, the parse failed.
> + first = orig_first;
> + return {first, errc::invalid_argument};
> + }
> +
> + // Parse the written exponent.
> + int written_exponent = 0;
> + if (first != last && *first == 'p')
> + {
> + // Tentatively consume the the 'p' and try to parse a decimal
> number.
> + const char* const fallback_first = first;
> + ++first;
> + if (first != last && *first == '+')
> + ++first;
> + from_chars_result fcr = from_chars(first, last, written_exponent,
> 10);
> + if (fcr.ptr == first)
> + // The parse failed, so undo consuming the 'p' and carry on as
> if the
> + // exponent was omitted (i.e. is 0).
> + first = fallback_first;
> + else
> + {
> + first = fcr.ptr;
> + if (mantissa != 0 && fcr.ec == errc::result_out_of_range)
> + // FIXME: Punt on large exponents for now.
> + return {first, errc::result_out_of_range};
> + }
> + }
> + int biased_exponent = written_exponent + exponent_bias;
> + if (exponent_adjustment != 0)
> + // The mantissa wasn't written in scientific form. Adjust the
> exponent
> + // so that we may assume scientific form.
> + //
> + // Examples;
> + // For input "a.bcp5", EXPONENT_ADJUSTMENT would be 0 since this
> + // written mantissa is already in scientific form.
> + // For input "ab.cp5", EXPONENT_ADJUSTMENT would be 4 since the
> + // scientific form is "a.bcp9".
> + // For input 0.0abcp5", EXPONENT_ADJUSTMENT would be -8 since the
> + // scientific form is "a.bcp-3".
> + biased_exponent += exponent_adjustment;
> +
> + // Shifts the mantissa to the right by AMOUNT while updating
> + // BIASED_EXPONENT, MIDPOINT_BIT and NONZERO_TAIL accordingly.
> + auto shift_mantissa = [&] (int amount) {
> + __glibcxx_assert(amount >= 0);
> + if (amount > mantissa_width + 1)
> + {
> + // Shifting the mantissa by an amount greater than its precision.
> + nonzero_tail |= midpoint_bit;
> + nonzero_tail |= mantissa != 0;
> + midpoint_bit = false;
> + mantissa = 0;
> + biased_exponent += amount;
> + }
> + else if (amount != 0)
> + {
> + nonzero_tail |= midpoint_bit;
> + nonzero_tail |= (mantissa & ((1ull << (amount - 1)) - 1)) != 0;
> + midpoint_bit = (mantissa & (1ull << (amount - 1))) != 0;
> + mantissa >>= amount;
> + biased_exponent += amount;
> + }
> + };
> +
> + if (mantissa != 0)
> + {
> + // If the leading hexit is not '1', shift MANTISSA to make it so.
> + // This normalizes input like "4.04p0" into "1.01p2".
> + const int leading_hexit = mantissa >> mantissa_width;
> + const int leading_hexit_width = __bit_width(leading_hexit); //
> FIXME: optimize?
> + __glibcxx_assert(leading_hexit_width >= 1 && leading_hexit_width
> <= 4);
> + shift_mantissa(leading_hexit_width - 1);
> + // After this adjustment, we can assume the leading hexit is a '1'.
> + __glibcxx_assert((mantissa >> mantissa_width) == 0x1);
> + }
> +
> + if (biased_exponent <= 0)
> + {
> + // This number is too small to be represented as a normal number,
> so
> + // try for a subnormal number by shifting the mantissa
> sufficiently.
> + // We need to shift by 1 more than -BIASED_EXPONENT because the
> leading
> + // mantissa bit is omitted in the representation of a normal
> number but
> + // not in a subnormal number.
> + shift_mantissa(-biased_exponent + 1);
> + __glibcxx_assert(!(mantissa & (1ull << mantissa_width)));
> + __glibcxx_assert(biased_exponent == 1);
> + biased_exponent = 0;
> + }
> +
> + // Perform round-to-nearest, tie-to-even rounding.
> + if (midpoint_bit && (nonzero_tail || (mantissa % 2) != 0))
> + {
> + // Rounding away from zero.
> + ++mantissa;
> + midpoint_bit = false;
> + nonzero_tail = false;
> +
> + // Deal with a couple of corner cases after rounding.
> + if (mantissa == (1ull << mantissa_width))
> + {
> + // We rounded the subnormal number 1.fffffffffffff...p-1023
> + // up to the normal number 1p-1022.
> + __glibcxx_assert(biased_exponent == 0);
> + ++biased_exponent;
> + }
> + else if (mantissa & (1ull << (mantissa_width + 1)))
> + {
> + // We rounded the normal number 1.fffffffffffff8pN (with
> maximal
> + // mantissa) up to to 1p(N+1).
> + mantissa >>= 1;
> + ++biased_exponent;
> + }
> + }
> + else
> + {
> + // Rounding towards zero.
> +
> + if (mantissa == 0 && (midpoint_bit || nonzero_tail))
> + {
> + // A nonzero number that rounds to zero is unrepresentable.
> + __glibcxx_assert(biased_exponent == 0);
> + return {first, errc::result_out_of_range};
> + }
> +
> + midpoint_bit = false;
> + nonzero_tail = false;
> + }
> +
> + if (mantissa != 0 && biased_exponent >= (1 << exponent_width) - 1)
> + // The exponent of this number is too large to be representable.
> + return {first, errc::result_out_of_range};
> +
> + uint_t result = 0;
> + if (mantissa == 0)
> + {
> + // Assemble a (possibly signed) zero.
> + if (sign_bit)
> + result |= 1ull << (exponent_width + mantissa_width);
> + }
> + else
> + {
> + // Assemble a nonzero normal or subnormal value.
> + result |= sign_bit;
> + result <<= exponent_width;
> + result |= biased_exponent;
> + result <<= mantissa_width;
> + result |= mantissa & ((1ull << mantissa_width) - 1);
> + // The implicit leading mantissa bit is set iff the number is
> normal.
> + __glibcxx_assert(((mantissa & (1ull << mantissa_width)) != 0)
> + == (biased_exponent != 0));
> + }
> + memcpy(&value, &result, sizeof(result));
> +
> + return {first, errc{}};
> + }
> +#endif
> +
> } // namespace
>
> // FIXME: This should be reimplemented so it doesn't use strtod and
> newlocale.
> @@ -406,6 +772,11 @@ from_chars_result
> from_chars(const char* first, const char* last, float& value,
> chars_format fmt) noexcept
> {
> +#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64
> + if (fmt == chars_format::hex)
> + return __floating_from_chars_hex(first, last, value);
> +#endif
> +
> errc ec = errc::invalid_argument;
> #if _GLIBCXX_USE_CXX11_ABI
> buffer_resource mr;
> @@ -432,6 +803,11 @@ from_chars_result
> from_chars(const char* first, const char* last, double& value,
> chars_format fmt) noexcept
> {
> +#if _GLIBCXX_FLOAT_IS_IEEE_BINARY32 && _GLIBCXX_DOUBLE_IS_IEEE_BINARY64
> + if (fmt == chars_format::hex)
> + return __floating_from_chars_hex(first, last, value);
> +#endif
> +
> errc ec = errc::invalid_argument;
> #if _GLIBCXX_USE_CXX11_ABI
> buffer_resource mr;
> diff --git a/libstdc++-v3/testsuite/20_util/from_chars/7.cc
> b/libstdc++-v3/testsuite/20_util/from_chars/7.cc
> new file mode 100644
> index 00000000000..090ad7a87bb
> --- /dev/null
> +++ b/libstdc++-v3/testsuite/20_util/from_chars/7.cc
> @@ -0,0 +1,151 @@
> +// Various testcases for binary64 hexfloat std::from_chars.
> +// { dg-do run { target c++17 } }
> +// { dg-require-effective-target ieee_floats }
> +
> +#include <charconv>
> +
> +#include <cfenv>
> +#include <cmath>
> +#include <cstring>
> +#include <cstdio>
> +#include <limits>
> +#include <testsuite_hooks.h>
> +
> +struct testcase {
> + const char* input;
> + size_t correct_idx;
> + std::errc correct_ec;
> + double correct_value;
> +};
> +
> +constexpr testcase testcases[] = {
> + { "1.fffffffffffff8p0", 18, {}, 0x1.fffffffffffff8p0 },
> + { "0.fffffffffffff8p-1022", 22, std::errc{}, 0x0.fffffffffffffep-1022 },
> + { "inf", 3, {}, std::numeric_limits<double>::infinity() },
> + { "inff", 3, {}, std::numeric_limits<double>::infinity() },
> + { "-inf", 4, {}, -std::numeric_limits<double>::infinity() },
> + { "-inff", 4, {}, -std::numeric_limits<double>::infinity() },
> + { "NAN", 3, {}, std::numeric_limits<double>::quiet_NaN() },
> + { "-NAN", 4, {}, std::numeric_limits<double>::quiet_NaN() },
> + { "NAN()", 5, {}, std::numeric_limits<double>::quiet_NaN() },
> + { "-NAN()", 6, {}, std::numeric_limits<double>::quiet_NaN() },
> + { "-NAN(test)", 10, {}, std::numeric_limits<double>::quiet_NaN() },
> + { "-NAN(test", 4, {}, std::numeric_limits<double>::quiet_NaN() },
> + { "-NAN(", 4, {}, std::numeric_limits<double>::quiet_NaN() },
> + { "0.000000000000001p-100000000000000000", 37,
> std::errc::result_out_of_range, 0 },
> + { "-lol", 0, std::errc::invalid_argument, 1 },
> + { " 0", 0, std::errc::invalid_argument, 1 },
> + { "", 0, std::errc::invalid_argument, 0 },
> + { "1", 1, {}, 1 },
> + { "2", 1, {}, 2 },
> + { "3", 1, {}, 3 },
> + { "4", 1, {}, 4 },
> + { "5", 1, {}, 5 },
> + { "6", 1, {}, 6 },
> + { "7", 1, {}, 7 },
> + { "8", 1, {}, 8 },
> + { "9", 1, {}, 9 },
> + { "a", 1, {}, 0xa },
> + { "b", 1, {}, 0xb },
> + { "c", 1, {}, 0xc },
> + { "d", 1, {}, 0xd },
> + { "e", 1, {}, 0xe },
> + { "f", 1, {}, 0xf },
> + { "0.000000000000000000000000000000000000000000001p-1022", 53,
> + std::errc::result_out_of_range, 0 },
> + { "0.00000000000000p-1022", 22, {}, 0 },
> + { "0.00000000000009", 16, {}, 0x0.00000000000009p0 },
> + { "0.0", 3, {}, 0 },
> + { "1p10000000000000000000000", 25, std::errc::result_out_of_range, 0 },
> + { "-0.0", 4, {}, -0.0 },
> + { "0.00000000000000", 16, {}, 0 },
> + { "0.0000000000000p-1022", 21, {}, 0 },
> + { ".", 0, std::errc::invalid_argument, 0 },
> + { "-.", 0, std::errc::invalid_argument, 0 },
> + { "0", 1, {}, 0 },
> + { "00", 2, {}, 0 },
> + { "00.", 3, {}, 0 },
> + { "0.", 2, {}, 0 },
> + { "1.ffffFFFFFFFFFF", 16, {}, 0x2 },
> + { "1.ffffffffffffff", 16, {}, 0x2 },
> + { "1.00000000000029", 16, {}, 0x1.0000000000003p0 },
> + { "0.00000000000008p-1022", 22, std::errc::result_out_of_range, 0 },
> + { "1.fffffffffffffp-1023", 21, {}, 0x1p-1022 },
> + { "1.fffffffffffff8p+1023", 22, std::errc::result_out_of_range, 0 },
> + { "0.ffffffffffffe8p-1022", 22, {}, 0x0.ffffffffffffep-1022 },
> + { "2.11111111111111", 16, {}, 0x1.0888888888889p+1 },
> + { "1.1111111111111", 15, {}, 0x1.1111111111111p0 },
> + { "1.11111111111111", 16, {}, 0x1.1111111111111p0 },
> + { "1.11111111111118", 16, {}, 0x1.1111111111112p0 },
> + { "1.11111111111128", 16, {}, 0x1.1111111111112p0 },
> + { "1.1111111111112801", 18, {}, 0x1.1111111111113p0 },
> + { "1.08888888888888", 16, {}, 0x1.0888888888888p0 },
> + { "1.088888888888888", 17, {}, 0x1.0888888888889p0 },
> + { "2.00000000000029", 16, {}, 0x2.0000000000002p0 },
> + { "0.ffffffffffffep-1022", 21, {}, 0x0.ffffffffffffep-1022 },
> + { "3.ffffffffffffep-1024", 21, {}, 0x1p-1022 },
> + { "1.00000000000008p+0", 19, {}, 1 },
> + { "1p-1023", 7, {}, 0x0.8p-1022 },
> + { "1p-1022", 7, {}, 0x1p-1022 },
> + { "1.1p-1033", 9, {}, 0x1.1p-1033 }, // 0.0022p-1022
> + { "22p-1038", 8, {}, 0x1.1p-1033 },
> + { "5", 1, {}, 0x5 },
> + { "a", 1, {}, 0xa },
> + { "1", 1, {}, 1.0 },
> + { "1p1", 3, {}, 0x1p1 },
> + { "1p-1", 4, {}, 0x1p-1 },
> + { "0", 1, {}, 0.0 },
> + { "A", 1, {}, 0xA },
> + { "-1", 2, {}, -1.0 },
> + { "-0", 2, {}, -0.0 },
> + { "42", 2, {}, 0x42p0 },
> + { "-42", 3, {}, -0x42p0 },
> + { ".1", 2, {}, 0x0.1p0 },
> + { "22p-1000", 8, {}, 0x22p-1000 },
> + { ".0000008", 8, {}, 0x.0000008p0 },
> + { ".0000008p-1022", 14, {}, 0x.0000008p-1022 },
> + { "1p-1074", 7, {}, 0x.0000000000001p-1022 },
> + { "9999999999999", 13, {}, 0x9999999999999p0 },
> + { "1.000000000000a000", 18, {}, 0x1.000000000000ap0 },
> + { "1.000000000000a001", 18, {}, 0x1.000000000000ap0 },
> + { "1.000000000000a800", 18, {}, 0x1.000000000000ap0 },
> + { "1.000000000000a801", 18, {}, 0x1.000000000000bp0 },
> + { "1.000000000000b800", 18, {}, 0x1.000000000000cp0 },
> + { "000000", 6, {}, 0x0 },
> + { "1p", 1, {}, 0x1 },
> + { "0p99999999999999999999", 22, {}, 0 },
> + { "1p99999999999999999999", 22, std::errc::result_out_of_range, 0 },
> + { "0p-99999999999999999999", 23, {}, 0 },
> + { "1p-99999999999999999999", 23, std::errc::result_out_of_range, 0 },
> + { "99999999999999999999999", 23, {}, 0x99999999999999999999999p0 },
> + { "-1.fffffffffffffp-1023", 22, {}, -0x1p-1022 },
> + { "1.337", 5, {}, 0x1.337p0 },
> +};
> +
> +void
> +test01()
> +{
> + for (auto [input,correct_idx,correct_ec,correct_value] : testcases)
> + {
> + double value;
> + auto [ptr,ec] = std::from_chars(input, input+strlen(input),
> + value, std::chars_format::hex);
> + VERIFY( ptr == input + correct_idx );
> + VERIFY( ec == correct_ec );
> + if (ec == std::errc{})
> + {
> + if (std::isnan(value) && std::isnan(value))
> + ;
> + else
> + {
> + VERIFY( value == correct_value );
> + VERIFY( !memcmp(&value, &correct_value, sizeof(value)) );
> + }
> + }
> + }
> +}
> +
> +int main()
> +{
> + test01();
> +}
> --
> 2.35.0.rc1
>
>
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH 2/6] libstdc++: Import the fast_float library
2022-01-16 18:06 ` [PATCH 2/6] libstdc++: Import the fast_float library Patrick Palka
@ 2022-01-17 10:45 ` Jonathan Wakely
2022-01-18 3:10 ` Hans-Peter Nilsson
1 sibling, 0 replies; 15+ messages in thread
From: Jonathan Wakely @ 2022-01-17 10:45 UTC (permalink / raw)
To: Patrick Palka; +Cc: gcc Patches, libstdc++
On Sun, 16 Jan 2022 at 18:13, Patrick Palka via Libstdc++ <
libstdc++@gcc.gnu.org> wrote:
> We're going to use the fast_float library in our (compiled-in)
> floating-point std::from_chars implementation for faster and more
> portable parsing of binary32/64 decimal strings.
>
> The single file fast_float.h is an amalgamation of the entire library,
> which can be (re)generated with the command
>
> python3 ./script/amalgamate.py --license=MIT \
> > $GCC_SRC/libstdc++-v3/c++17/fast_float/fast_float.h
>
Please mention that the script is in the fast_float repo (so people don't
look for it in our repo).
Please mention in the commit log that the code has a GPL-compatible licence.
>
> [1]: https://github.com/fastfloat/fast_float
>
> libstdc++-v3/ChangeLog:
>
> * src/c++17/fast_float/LOCAL_PATCHES: New file.
> * src/c++17/fast_float/MERGE: New file.
> * src/c++17/fast_float/README.fd: New file, copied from the
> fast_float library sources.
> * src/c++17/fast_float/fast_float.h: New file, an amalgamation
> of the fast_float library.
>
> Signed-off-by: Patrick Palka <ppalka@redhat.com>
>
This project is great. The licence is compatible, and the licence text and
copyright notices are preserved in the code being imported. The entire
license text is present in the header, so there is no need for a separate
licence file.
The symbols that will be added to libstdc++ are not uglified, but the
header is included inside an unnamed namespace, so we will not define any
non-reserved symbols in libstdc++.a (and they aren't exported from
libstdc++.so anyway).
OK for trunk.
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH 3/6] libstdc++: Apply modifications to our local copy of fast_float
2022-01-16 18:06 ` [PATCH 3/6] libstdc++: Apply modifications to our local copy of fast_float Patrick Palka
@ 2022-01-17 10:46 ` Jonathan Wakely
0 siblings, 0 replies; 15+ messages in thread
From: Jonathan Wakely @ 2022-01-17 10:46 UTC (permalink / raw)
To: Patrick Palka; +Cc: gcc Patches, libstdc++
On Sun, 16 Jan 2022 at 18:07, Patrick Palka via Libstdc++ <
libstdc++@gcc.gnu.org> wrote:
> This performs the following modifications to our local copy of fast_float
> in order to make it more readily usable in our std::from_chars
> implementation:
>
> * Remove system #includes
> * Replace stray call to assert
> * Use the standard chars_format and from_chars_result types
>
> libstdc++-v3/ChangeLog:
>
> * src/c++17/fast_float/LOCAL_PATCHES: Update.
> * src/c++17/fast_float/fast_float.h: Apply local modifications.
>
>
OK for trunk.
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH 4/6] libstdc++: Adjust fast_float's over/underflow behavior for conformnace
2022-01-16 18:06 ` [PATCH 4/6] libstdc++: Adjust fast_float's over/underflow behavior for conformnace Patrick Palka
@ 2022-01-17 10:49 ` Jonathan Wakely
2022-01-17 20:05 ` Patrick Palka
0 siblings, 1 reply; 15+ messages in thread
From: Jonathan Wakely @ 2022-01-17 10:49 UTC (permalink / raw)
To: Patrick Palka; +Cc: gcc Patches, libstdc++
On Sun, 16 Jan 2022 at 18:12, Patrick Palka via Libstdc++ <
libstdc++@gcc.gnu.org> wrote:
> This makes fast_float handle the situation where std::from_chars is
> specified to return result_out_of_range, i.e. when the parsed value
> is outside the representable range of the floating-point type.
>
> This adjusts fast_float's behavior in case of over/underflow: instead of
> returning errc{} and setting value to +-0 or +-infinity, return
> result_out_of_range and don't modify value, as per [charconv.from.chars]/1.
>
> libstdc++-v3/ChangeLog:
>
> * src/c++17/fast_float/LOCAL_PATCHES: Update.
> * src/c++17/fast_float/fast_float.h (from_chars_advanced): In
> case of over/underflow, return errc::result_out_of_range and don't
> modify 'value'.
>
>
Typo in the commit summary line "conformnace".
OK for trunk.
Please report this as an issue to the upstream project, if you didn't
already (and if they haven't documented this as an intentional deviation
from the standard).
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH 5/6] libstdc++: Use fast_float in std::from_chars for binary32/64
2022-01-16 18:06 ` [PATCH 5/6] libstdc++: Use fast_float in std::from_chars for binary32/64 Patrick Palka
@ 2022-01-17 10:50 ` Jonathan Wakely
0 siblings, 0 replies; 15+ messages in thread
From: Jonathan Wakely @ 2022-01-17 10:50 UTC (permalink / raw)
To: Patrick Palka; +Cc: gcc Patches, libstdc++
On Sun, 16 Jan 2022 at 18:09, Patrick Palka via Libstdc++ <
libstdc++@gcc.gnu.org> wrote:
> This makes our std::from_chars implementation use fast_float for parsing
> chars_format::scientific/fixed/general parsing into binary32/64 values.
> For other floating-point formats we still use the fallback implementation
> that goes through the strtod family of functions.
>
> libstdc++-v3/ChangeLog:
>
> * src/c++17/floating_from_chars.cc: (USE_LIB_FAST_FLOAT):
> Conditionally define, and use it to conditionally include
> fast_float.
> (from_chars): Use fast_float for float and double when
> USE_LIB_FAST_FLOAT.
>
>
OK for trunk.
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH 6/6] libstdc++: Import MSVC floating-point std::from_chars testcases
2022-01-16 18:06 ` [PATCH 6/6] libstdc++: Import MSVC floating-point std::from_chars testcases Patrick Palka
@ 2022-01-17 10:54 ` Jonathan Wakely
2022-01-17 20:23 ` Patrick Palka
0 siblings, 1 reply; 15+ messages in thread
From: Jonathan Wakely @ 2022-01-17 10:54 UTC (permalink / raw)
To: Patrick Palka; +Cc: gcc Patches, libstdc++
On Sun, 16 Jan 2022 at 18:17, Patrick Palka via Libstdc++ <
libstdc++@gcc.gnu.org> wrote:
> libstdc++-v3/ChangeLog:
>
> * testsuite/20_util/from_chars/double.cc: New test, consisting
> of testcases extracted from the MSVC STL testsuite.
> * testsuite/20_util/from_chars/float.cc: New test.
> ---
> .../testsuite/20_util/from_chars/double.cc | 1674 +++++++++++++++++
> .../testsuite/20_util/from_chars/float.cc | 290 +++
> 2 files changed, 1964 insertions(+)
> create mode 100644 libstdc++-v3/testsuite/20_util/from_chars/double.cc
> create mode 100644 libstdc++-v3/testsuite/20_util/from_chars/float.cc
>
> diff --git a/libstdc++-v3/testsuite/20_util/from_chars/double.cc
> b/libstdc++-v3/testsuite/20_util/from_chars/double.cc
> new file mode 100644
> index 00000000000..ce53a1c56c2
> --- /dev/null
> +++ b/libstdc++-v3/testsuite/20_util/from_chars/double.cc
> @@ -0,0 +1,1674 @@
> +// This file consists of testcases extracted from the MSVC STL testsuite.
> +
> +// Copyright (c) Microsoft Corporation.
> +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
>
I think we should probably move (or copy) the
libstdc++-v3/include/pstl/LICENSE.txt file to another directory, since we
have files using this licence in other places too.
Please hold off committing this one while I think about that (and remind me
if you don't hear back from me with a decision).
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH 4/6] libstdc++: Adjust fast_float's over/underflow behavior for conformnace
2022-01-17 10:49 ` Jonathan Wakely
@ 2022-01-17 20:05 ` Patrick Palka
0 siblings, 0 replies; 15+ messages in thread
From: Patrick Palka @ 2022-01-17 20:05 UTC (permalink / raw)
To: Jonathan Wakely; +Cc: gcc Patches, libstdc++
On Mon, Jan 17, 2022 at 5:49 AM Jonathan Wakely <jwakely@redhat.com> wrote:
>
>
>
> On Sun, 16 Jan 2022 at 18:12, Patrick Palka via Libstdc++ <libstdc++@gcc.gnu.org> wrote:
>>
>> This makes fast_float handle the situation where std::from_chars is
>> specified to return result_out_of_range, i.e. when the parsed value
>> is outside the representable range of the floating-point type.
>>
>> This adjusts fast_float's behavior in case of over/underflow: instead of
>> returning errc{} and setting value to +-0 or +-infinity, return
>> result_out_of_range and don't modify value, as per [charconv.from.chars]/1.
>>
>> libstdc++-v3/ChangeLog:
>>
>> * src/c++17/fast_float/LOCAL_PATCHES: Update.
>> * src/c++17/fast_float/fast_float.h (from_chars_advanced): In
>> case of over/underflow, return errc::result_out_of_range and don't
>> modify 'value'.
>>
>
> Typo in the commit summary line "conformnace".
>
> OK for trunk.
>
> Please report this as an issue to the upstream project, if you didn't already (and if they haven't documented this as an intentional deviation from the standard).
This behavior difference isn't documented AFAICT, so I reported the
issue upstream at https://github.com/fastfloat/fast_float/issues/120
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH 6/6] libstdc++: Import MSVC floating-point std::from_chars testcases
2022-01-17 10:54 ` Jonathan Wakely
@ 2022-01-17 20:23 ` Patrick Palka
0 siblings, 0 replies; 15+ messages in thread
From: Patrick Palka @ 2022-01-17 20:23 UTC (permalink / raw)
To: Jonathan Wakely; +Cc: gcc Patches, libstdc++
On Mon, Jan 17, 2022 at 5:54 AM Jonathan Wakely <jwakely@redhat.com> wrote:
>
>
>
> On Sun, 16 Jan 2022 at 18:17, Patrick Palka via Libstdc++ <libstdc++@gcc.gnu.org> wrote:
>>
>> libstdc++-v3/ChangeLog:
>>
>> * testsuite/20_util/from_chars/double.cc: New test, consisting
>> of testcases extracted from the MSVC STL testsuite.
>> * testsuite/20_util/from_chars/float.cc: New test.
>> ---
>> .../testsuite/20_util/from_chars/double.cc | 1674 +++++++++++++++++
>> .../testsuite/20_util/from_chars/float.cc | 290 +++
>> 2 files changed, 1964 insertions(+)
>> create mode 100644 libstdc++-v3/testsuite/20_util/from_chars/double.cc
>> create mode 100644 libstdc++-v3/testsuite/20_util/from_chars/float.cc
>>
>> diff --git a/libstdc++-v3/testsuite/20_util/from_chars/double.cc b/libstdc++-v3/testsuite/20_util/from_chars/double.cc
>> new file mode 100644
>> index 00000000000..ce53a1c56c2
>> --- /dev/null
>> +++ b/libstdc++-v3/testsuite/20_util/from_chars/double.cc
>> @@ -0,0 +1,1674 @@
>> +// This file consists of testcases extracted from the MSVC STL testsuite.
>> +
>> +// Copyright (c) Microsoft Corporation.
>> +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
>
>
> I think we should probably move (or copy) the libstdc++-v3/include/pstl/LICENSE.txt file to another directory, since we have files using this licence in other places too.
>
> Please hold off committing this one while I think about that (and remind me if you don't hear back from me with a decision).
Will do. I committed the rest of the series, thanks a lot!
^ permalink raw reply [flat|nested] 15+ messages in thread
* Re: [PATCH 2/6] libstdc++: Import the fast_float library
2022-01-16 18:06 ` [PATCH 2/6] libstdc++: Import the fast_float library Patrick Palka
2022-01-17 10:45 ` Jonathan Wakely
@ 2022-01-18 3:10 ` Hans-Peter Nilsson
1 sibling, 0 replies; 15+ messages in thread
From: Hans-Peter Nilsson @ 2022-01-18 3:10 UTC (permalink / raw)
To: Patrick Palka; +Cc: gcc-patches, libstdc++
> From: Patrick Palka via Gcc-patches <gcc-patches@gcc.gnu.org>
> Date: Sun, 16 Jan 2022 19:06:48 +0100
> We're going to use the fast_float library in our (compiled-in)
> floating-point std::from_chars implementation for faster and more
> portable parsing of binary32/64 decimal strings.
>
> The single file fast_float.h is an amalgamation of the entire library,
> which can be (re)generated with the command
>
> python3 ./script/amalgamate.py --license=MIT \
> > $GCC_SRC/libstdc++-v3/c++17/fast_float/fast_float.h
>
> [1]: https://github.com/fastfloat/fast_float
>
> libstdc++-v3/ChangeLog:
>
> * src/c++17/fast_float/LOCAL_PATCHES: New file.
> * src/c++17/fast_float/MERGE: New file.
> * src/c++17/fast_float/README.fd: New file, copied from the
> fast_float library sources.
> * src/c++17/fast_float/fast_float.h: New file, an amalgamation
> of the fast_float library.
This broke builds for newlib targets, as they don't have
<endian.h> but <machine/endian.h>. See PR104080 for
details. After the obvious fix, there seems to be some
additional type mismatch also quoted in the bugzilla.
Not thrilled by large stage3 changes. The fallout risk
should have been obvious. :(
(And after this, there's a regress-84 to sort out. Bah.)
brgds, H-P
^ permalink raw reply [flat|nested] 15+ messages in thread
end of thread, other threads:[~2022-01-18 3:10 UTC | newest]
Thread overview: 15+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-01-16 18:06 [PATCH 1/6 v2] libstdc++: Directly implement hexfloat std::from_chars for binary32/64 Patrick Palka
2022-01-16 18:06 ` [PATCH 2/6] libstdc++: Import the fast_float library Patrick Palka
2022-01-17 10:45 ` Jonathan Wakely
2022-01-18 3:10 ` Hans-Peter Nilsson
2022-01-16 18:06 ` [PATCH 3/6] libstdc++: Apply modifications to our local copy of fast_float Patrick Palka
2022-01-17 10:46 ` Jonathan Wakely
2022-01-16 18:06 ` [PATCH 4/6] libstdc++: Adjust fast_float's over/underflow behavior for conformnace Patrick Palka
2022-01-17 10:49 ` Jonathan Wakely
2022-01-17 20:05 ` Patrick Palka
2022-01-16 18:06 ` [PATCH 5/6] libstdc++: Use fast_float in std::from_chars for binary32/64 Patrick Palka
2022-01-17 10:50 ` Jonathan Wakely
2022-01-16 18:06 ` [PATCH 6/6] libstdc++: Import MSVC floating-point std::from_chars testcases Patrick Palka
2022-01-17 10:54 ` Jonathan Wakely
2022-01-17 20:23 ` Patrick Palka
2022-01-17 10:34 ` [PATCH 1/6 v2] libstdc++: Directly implement hexfloat std::from_chars for binary32/64 Jonathan Wakely
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).