From patchwork Tue Nov 16 00:25:01 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Patrick Palka X-Patchwork-Id: 47737 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 5C840385782B for ; Tue, 16 Nov 2021 00:31:34 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 5C840385782B DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1637022694; bh=k4NiWK6KgbAcG68tKvDzN/lusHs1cRkYQtaDGUE1A/E=; h=To:Subject:Date:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:Cc:From; b=drYRSx3a7hO/sjzSNyFaL6B/TZ6WroNgOlAGmCwxY7XRPySyVnqncUCCRb5SvB8FJ IIgxnERnnZHq4qdNtCnJDZZ0UIIUWcOJ5+wtE5mQFzZ7zfkRTr8jw0a2oqMgudfNvW gjZEcujDHWKJDznV5Fw5iNixTwscBxur1mDm0410= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [216.205.24.124]) by sourceware.org (Postfix) with ESMTPS id 75AD93857809 for ; Tue, 16 Nov 2021 00:25:25 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 75AD93857809 Received: from mail-qv1-f71.google.com (mail-qv1-f71.google.com [209.85.219.71]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-449-Kfz5h0c6MP2DHPVfHDHYgA-1; Mon, 15 Nov 2021 19:25:23 -0500 X-MC-Unique: Kfz5h0c6MP2DHPVfHDHYgA-1 Received: by mail-qv1-f71.google.com with SMTP id g12-20020a0562141ccc00b003c0322ea7b6so11747282qvd.19 for ; Mon, 15 Nov 2021 16:25:23 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=k4NiWK6KgbAcG68tKvDzN/lusHs1cRkYQtaDGUE1A/E=; b=mmrlZqANDjDFUfjFg7RuVfGSyF+T5i+iB+feiUuT8Vfgj4LOGL2J27ftXjLzSDBpM1 HTxOIdS9dbZIq5DpndY+/Wqx4DjUlRp6mPBF3Fj+zMEn8Blc95htZhgcic4L47vzdYvs DLKhARkJUHdY1SgBIfE14y1gfpU2m/t2dY1Q481ik/obD6UzrRYMaYSfnVI/ZOFz7I7c DkE5e5A3hJOjR3MpZGDLgPhS0koApFYNJ8kLLdWgCc54GBVhiKRIMgTmnT/L2dzSaDYE pJnUkNCVA6AgPTW6MSpqSQQY1MQd5+iOp6csas5KCfzsJ5ck3k7LlZnodZYg4teSjegM I6Yw== X-Gm-Message-State: AOAM532qyXqcpw1WXvk5L5/z/2rBkHw8xtFJJd/g4mMNMDklJyvq9Jjw ndpo0aACMMkcIQQWu0EvFgs4NnJVLvepbnFNUOp6USsGym+yVGv/bLseUrMT0yGlKmljpodpsSZ wUZe+mwqNgRKkOatenW9mqJQjfYEra26HoXa3iFdgpCT+tlK6SJizphMAzeWdr6yo/t0= X-Received: by 2002:a05:622a:1810:: with SMTP id t16mr3373894qtc.348.1637022317078; Mon, 15 Nov 2021 16:25:17 -0800 (PST) X-Google-Smtp-Source: ABdhPJxg9JThl8VCi1QBiWpz+2SfFDrDKjXMnNG/nPSXu93aRaaR3zwbIP678LUczePrXlCLozkp/g== X-Received: by 2002:a05:622a:1810:: with SMTP id t16mr3373674qtc.348.1637022314843; Mon, 15 Nov 2021 16:25:14 -0800 (PST) Received: from localhost.localdomain (ool-457d493a.dyn.optonline.net. [69.125.73.58]) by smtp.gmail.com with ESMTPSA id j19sm7836545qkp.28.2021.11.15.16.25.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 15 Nov 2021 16:25:14 -0800 (PST) To: gcc-patches@gcc.gnu.org Subject: [PATCH 1/5] libstdc++: Import the fast_float library Date: Mon, 15 Nov 2021 19:25:01 -0500 Message-Id: <20211116002505.2324582-1-ppalka@redhat.com> X-Mailer: git-send-email 2.34.0 MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-16.0 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=unavailable autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Patrick Palka via Gcc-patches From: Patrick Palka Reply-To: Patrick Palka Cc: libstdc++@gcc.gnu.org Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" This copies the fast_float library[1] into the compiled-in library sources. We're going to use this library in our floating-point std::from_chars implementation for faster and more portable parsing of binary32/64 decimal strings. [1]: https://github.com/fastfloat/fast_float Series tested on x86_64, i686, ppc64, ppc64le and aarch64, does it look OK for trunk? libstdc++-v3/ChangeLog: * src/c++17/fast_float/LICENSE-APACHE: New file. * src/c++17/fast_float/LICENSE-MIT: New file. * src/c++17/fast_float/LOCAL_PATCHES: New file. * src/c++17/fast_float/MERGE: New file. * src/c++17/fast_float/ascii_number.h, src/c++17/fast_float/bigint.h, src/c++17/fast_float/decimal_to_binary.h, src/c++17/fast_float/digit_comparison.h, src/c++17/fast_float/fast_float.h, src/c++17/fast_float/fast_table.h, src/c++17/fast_float/float_common.h, src/c++17/fast_float/parse_number.h: Import these files from the fast_float library. Signed-off-by: Patrick Palka --- .../src/c++17/fast_float/LICENSE-APACHE | 190 +++++ libstdc++-v3/src/c++17/fast_float/LICENSE-MIT | 27 + .../src/c++17/fast_float/LOCAL_PATCHES | 0 libstdc++-v3/src/c++17/fast_float/MERGE | 4 + .../src/c++17/fast_float/ascii_number.h | 231 ++++++ libstdc++-v3/src/c++17/fast_float/bigint.h | 590 +++++++++++++++ .../src/c++17/fast_float/decimal_to_binary.h | 194 +++++ .../src/c++17/fast_float/digit_comparison.h | 423 +++++++++++ .../src/c++17/fast_float/fast_float.h | 63 ++ .../src/c++17/fast_float/fast_table.h | 699 ++++++++++++++++++ .../src/c++17/fast_float/float_common.h | 362 +++++++++ .../src/c++17/fast_float/parse_number.h | 113 +++ 12 files changed, 2896 insertions(+) create mode 100644 libstdc++-v3/src/c++17/fast_float/LICENSE-APACHE create mode 100644 libstdc++-v3/src/c++17/fast_float/LICENSE-MIT 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/ascii_number.h create mode 100644 libstdc++-v3/src/c++17/fast_float/bigint.h create mode 100644 libstdc++-v3/src/c++17/fast_float/decimal_to_binary.h create mode 100644 libstdc++-v3/src/c++17/fast_float/digit_comparison.h create mode 100644 libstdc++-v3/src/c++17/fast_float/fast_float.h create mode 100644 libstdc++-v3/src/c++17/fast_float/fast_table.h create mode 100644 libstdc++-v3/src/c++17/fast_float/float_common.h create mode 100644 libstdc++-v3/src/c++17/fast_float/parse_number.h diff --git a/libstdc++-v3/src/c++17/fast_float/LICENSE-APACHE b/libstdc++-v3/src/c++17/fast_float/LICENSE-APACHE new file mode 100644 index 00000000000..26f4398f249 --- /dev/null +++ b/libstdc++-v3/src/c++17/fast_float/LICENSE-APACHE @@ -0,0 +1,190 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + Copyright 2021 The fast_float authors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/libstdc++-v3/src/c++17/fast_float/LICENSE-MIT b/libstdc++-v3/src/c++17/fast_float/LICENSE-MIT new file mode 100644 index 00000000000..2fb2a37ad7f --- /dev/null +++ b/libstdc++-v3/src/c++17/fast_float/LICENSE-MIT @@ -0,0 +1,27 @@ +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. 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/ascii_number.h b/libstdc++-v3/src/c++17/fast_float/ascii_number.h new file mode 100644 index 00000000000..3e6bb3e9ef3 --- /dev/null +++ b/libstdc++-v3/src/c++17/fast_float/ascii_number.h @@ -0,0 +1,231 @@ +#ifndef FASTFLOAT_ASCII_NUMBER_H +#define FASTFLOAT_ASCII_NUMBER_H + +#include +#include +#include +#include + +#include "float_common.h" + +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 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 diff --git a/libstdc++-v3/src/c++17/fast_float/bigint.h b/libstdc++-v3/src/c++17/fast_float/bigint.h new file mode 100644 index 00000000000..b56cb9b03b3 --- /dev/null +++ b/libstdc++-v3/src/c++17/fast_float/bigint.h @@ -0,0 +1,590 @@ +#ifndef FASTFLOAT_BIGINT_H +#define FASTFLOAT_BIGINT_H + +#include +#include +#include +#include + +#include "float_common.h" + +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_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 +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 +inline bool small_add_from(stackvec& 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 +fastfloat_really_inline bool small_add(stackvec& vec, limb y) noexcept { + return small_add_from(vec, y, 0); +} + +// multiply bigint by scalar value. +template +inline bool small_mul(stackvec& 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 +bool large_add_from(stackvec& 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 +fastfloat_really_inline bool large_add_from(stackvec& x, limb_span y) noexcept { + return large_add_from(x, y, 0); +} + +// grade-school multiplication algorithm +template +bool long_mul(stackvec& x, limb_span y) noexcept { + limb_span xs = limb_span(x.data, x.len()); + stackvec 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 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 +bool large_mul(stackvec& 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 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 diff --git a/libstdc++-v3/src/c++17/fast_float/decimal_to_binary.h b/libstdc++-v3/src/c++17/fast_float/decimal_to_binary.h new file mode 100644 index 00000000000..6da6c66a3ac --- /dev/null +++ b/libstdc++-v3/src/c++17/fast_float/decimal_to_binary.h @@ -0,0 +1,194 @@ +#ifndef FASTFLOAT_DECIMAL_TO_BINARY_H +#define FASTFLOAT_DECIMAL_TO_BINARY_H + +#include "float_common.h" +#include "fast_table.h" +#include +#include +#include +#include +#include +#include + +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 +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 +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 +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(q, w); + return compute_error_scaled(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 +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(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(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 diff --git a/libstdc++-v3/src/c++17/fast_float/digit_comparison.h b/libstdc++-v3/src/c++17/fast_float/digit_comparison.h new file mode 100644 index 00000000000..7ffe874303b --- /dev/null +++ b/libstdc++-v3/src/c++17/fast_float/digit_comparison.h @@ -0,0 +1,423 @@ +#ifndef FASTFLOAT_DIGIT_COMPARISON_H +#define FASTFLOAT_DIGIT_COMPARISON_H + +#include +#include +#include +#include + +#include "float_common.h" +#include "bigint.h" +#include "ascii_number.h" + +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 +fastfloat_really_inline adjusted_mantissa to_extended(T value) noexcept { + adjusted_mantissa am; + int32_t bias = binary_format::mantissa_explicit_bits() - binary_format::minimum_exponent(); + if (std::is_same::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::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::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 +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 +fastfloat_really_inline void round(adjusted_mantissa& am, callback cb) noexcept { + int32_t mantissa_shift = 64 - binary_format::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::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::mantissa_explicit_bits())) { + am.mantissa = (uint64_t(1) << binary_format::mantissa_explicit_bits()); + am.power2++; + } + + // check for infinite: we could have carried to an infinite power + am.mantissa &= ~(uint64_t(1) << binary_format::mantissa_explicit_bits()); + if (am.power2 >= binary_format::infinite_power()) { + am.power2 = binary_format::infinite_power(); + am.mantissa = 0; + } +} + +template +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 +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::mantissa_explicit_bits() - binary_format::minimum_exponent(); + answer.power2 = bigmant.bit_length() - 64 + bias; + + round(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 +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(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(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 +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::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(bigmant, exponent); + } else { + return negative_digit_comp(bigmant, am, exponent); + } +} + +} // namespace fast_float + +#endif 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..3c483803af3 --- /dev/null +++ b/libstdc++-v3/src/c++17/fast_float/fast_float.h @@ -0,0 +1,63 @@ +#ifndef FASTFLOAT_FAST_FLOAT_H +#define FASTFLOAT_FAST_FLOAT_H + +#include + +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 +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 +from_chars_result from_chars_advanced(const char *first, const char *last, + T &value, parse_options options) noexcept; + +} +#include "parse_number.h" +#endif // FASTFLOAT_FAST_FLOAT_H diff --git a/libstdc++-v3/src/c++17/fast_float/fast_table.h b/libstdc++-v3/src/c++17/fast_float/fast_table.h new file mode 100644 index 00000000000..5766274ca41 --- /dev/null +++ b/libstdc++-v3/src/c++17/fast_float/fast_table.h @@ -0,0 +1,699 @@ +#ifndef FASTFLOAT_FAST_TABLE_H +#define FASTFLOAT_FAST_TABLE_H + +#include + +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 +struct powers_template { + +constexpr static int smallest_power_of_five = binary_format::smallest_power_of_ten(); +constexpr static int largest_power_of_five = binary_format::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 +const uint64_t powers_template::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 diff --git a/libstdc++-v3/src/c++17/fast_float/float_common.h b/libstdc++-v3/src/c++17/fast_float/float_common.h new file mode 100644 index 00000000000..c8e7e4fc99e --- /dev/null +++ b/libstdc++-v3/src/c++17/fast_float/float_common.h @@ -0,0 +1,362 @@ +#ifndef FASTFLOAT_FLOAT_COMMON_H +#define FASTFLOAT_FLOAT_COMMON_H + +#include +#include +#include +#include + +#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 +#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 +#elif defined(sun) || defined(__sun) +#include +#else +#include +#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 +#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 +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 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::mantissa_explicit_bits() { + return 52; +} +template <> inline constexpr int binary_format::mantissa_explicit_bits() { + return 23; +} + +template <> inline constexpr int binary_format::max_exponent_round_to_even() { + return 23; +} + +template <> inline constexpr int binary_format::max_exponent_round_to_even() { + return 10; +} + +template <> inline constexpr int binary_format::min_exponent_round_to_even() { + return -4; +} + +template <> inline constexpr int binary_format::min_exponent_round_to_even() { + return -17; +} + +template <> inline constexpr int binary_format::minimum_exponent() { + return -1023; +} +template <> inline constexpr int binary_format::minimum_exponent() { + return -127; +} + +template <> inline constexpr int binary_format::infinite_power() { + return 0x7FF; +} +template <> inline constexpr int binary_format::infinite_power() { + return 0xFF; +} + +template <> inline constexpr int binary_format::sign_index() { return 63; } +template <> inline constexpr int binary_format::sign_index() { return 31; } + +template <> inline constexpr int binary_format::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::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::max_exponent_fast_path() { + return 22; +} +template <> inline constexpr int binary_format::max_exponent_fast_path() { + return 10; +} + +template <> inline constexpr uint64_t binary_format::max_mantissa_fast_path() { + return uint64_t(2) << mantissa_explicit_bits(); +} +template <> inline constexpr uint64_t binary_format::max_mantissa_fast_path() { + return uint64_t(2) << mantissa_explicit_bits(); +} + +template <> +inline constexpr double binary_format::exact_power_of_ten(int64_t power) { + return powers_of_ten_double[power]; +} +template <> +inline constexpr float binary_format::exact_power_of_ten(int64_t power) { + + return powers_of_ten_float[power]; +} + + +template <> +inline constexpr int binary_format::largest_power_of_ten() { + return 308; +} +template <> +inline constexpr int binary_format::largest_power_of_ten() { + return 38; +} + +template <> +inline constexpr int binary_format::smallest_power_of_ten() { + return -342; +} +template <> +inline constexpr int binary_format::smallest_power_of_ten() { + return -65; +} + +template <> inline constexpr size_t binary_format::max_digits() { + return 769; +} +template <> inline constexpr size_t binary_format::max_digits() { + return 114; +} + +template +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::mantissa_explicit_bits(); + word = negative + ? word | (uint64_t(1) << binary_format::sign_index()) : word; +#if FASTFLOAT_IS_BIG_ENDIAN == 1 + if (std::is_same::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 diff --git a/libstdc++-v3/src/c++17/fast_float/parse_number.h b/libstdc++-v3/src/c++17/fast_float/parse_number.h new file mode 100644 index 00000000000..62ae3b039e6 --- /dev/null +++ b/libstdc++-v3/src/c++17/fast_float/parse_number.h @@ -0,0 +1,113 @@ +#ifndef FASTFLOAT_PARSE_NUMBER_H +#define FASTFLOAT_PARSE_NUMBER_H + +#include "ascii_number.h" +#include "decimal_to_binary.h" +#include "digit_comparison.h" + +#include +#include +#include +#include + +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 +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::quiet_NaN() : std::numeric_limits::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::infinity() : std::numeric_limits::infinity(); + return answer; + } + } + answer.ec = std::errc::invalid_argument; + return answer; +} + +} // namespace detail + +template +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 +from_chars_result from_chars_advanced(const char *first, const char *last, + T &value, parse_options options) noexcept { + + static_assert (std::is_same::value || std::is_same::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::min_exponent_fast_path() <= pns.exponent && pns.exponent <= binary_format::max_exponent_fast_path() && pns.mantissa <=binary_format::max_mantissa_fast_path() && !pns.too_many_digits) { + value = T(pns.mantissa); + if (pns.exponent < 0) { value = value / binary_format::exact_power_of_ten(-pns.exponent); } + else { value = value * binary_format::exact_power_of_ten(pns.exponent); } + if (pns.negative) { value = -value; } + return answer; + } + adjusted_mantissa am = compute_float>(pns.exponent, pns.mantissa); + if(pns.too_many_digits && am.power2 >= 0) { + if(am != compute_float>(pns.exponent, pns.mantissa + 1)) { + am = compute_error>(pns.exponent, pns.mantissa); + } + } + // If we called compute_float>(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(pns, am); } + to_float(pns.negative, am, value); + return answer; +} + +} // namespace fast_float + +#endif From patchwork Tue Nov 16 00:25:02 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Patrick Palka X-Patchwork-Id: 47734 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 61A0B3858039 for ; Tue, 16 Nov 2021 00:25:48 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 61A0B3858039 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1637022348; bh=MSfF6dohJNJfl8T+4RW3ssgybkqogDxP77ju2d2mIaM=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To:Cc: From; b=l/74uIIOwRB689zvSeZ7XurwS/61QY9pWDk+gGpnfHL/cuYYdTxJL4N+Ry/AvoFhf uzZYBm7vtpsH7Yr0y+g702AdqXxDLRJImD9NpUrteko1Mh4ozO81cvbUlM0ue9SOAP Wx31UBIb3115JOgzWnNTUjvgpkAP/suNjCd0KHSk= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id 876503858405 for ; Tue, 16 Nov 2021 00:25:18 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 876503858405 Received: from mail-qv1-f70.google.com (mail-qv1-f70.google.com [209.85.219.70]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-502-OIwp7rduOyqNbHTiDa5jOg-1; Mon, 15 Nov 2021 19:25:17 -0500 X-MC-Unique: OIwp7rduOyqNbHTiDa5jOg-1 Received: by mail-qv1-f70.google.com with SMTP id g12-20020a0562141ccc00b003c0322ea7b6so11747069qvd.19 for ; Mon, 15 Nov 2021 16:25:17 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=MSfF6dohJNJfl8T+4RW3ssgybkqogDxP77ju2d2mIaM=; b=5BWlVTpfjEEyuirB2Nf5IZCNpQ72FgT17+DtofcDWPWWrKsDNXjdpw/VMiH97rfZCP EctcSSezIQsL6VXrq4xd7mXrYRVp+s3fwRFQS+/DRARhuB0GaleQUqqUJrQONbAFQGVj oV2t5Xy0YFReKdxcTPnAALNRSUYuCF4V8WuPczbdmQsmbUSvaqC+lOerTs5QucKykzXT rPYiPEyKq8YQasUmBSaHUshMa3jIyJsab2JK4JWB+y9NFf4iSQQEL2ON53LoS5Vq2E1T W5lcOaDpAJ9EdsciEyH8216ysBrMrszkDJjCQQ+tQQlkNzX9zJ7flPiJdJNMBTW0yQtJ 3Pig== X-Gm-Message-State: AOAM531P+tsApfncVgjGyYq4cdZ7pE4K+BLic2lHTEQeFKNKlTtdDtmV v2STk9fOfCEZbdnJpEzdywhdKFKdMsRx1VZE8+GgqK91t9+k82HD++f4qfNpO1D+4WUMAmYLa70 H7VeW01NHi0b9KF3fKT9jZ1j1oRKr7XhcSG4nqjMNvrATMl9d3LEFBrlYNwneGzsG89E= X-Received: by 2002:ac8:3d49:: with SMTP id u9mr3357231qtf.264.1637022316444; Mon, 15 Nov 2021 16:25:16 -0800 (PST) X-Google-Smtp-Source: ABdhPJxqrfZRv7nIqekxnFxpKJ621S1UMG9pSsPVBMRMTaUi4MXcvRQQcYVTNY2dSNEDyczExnwRbg== X-Received: by 2002:ac8:3d49:: with SMTP id u9mr3357197qtf.264.1637022316172; Mon, 15 Nov 2021 16:25:16 -0800 (PST) Received: from localhost.localdomain (ool-457d493a.dyn.optonline.net. [69.125.73.58]) by smtp.gmail.com with ESMTPSA id j19sm7836545qkp.28.2021.11.15.16.25.15 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 15 Nov 2021 16:25:15 -0800 (PST) To: gcc-patches@gcc.gnu.org Subject: [PATCH 2/5] libstdc++: Apply modifications to our local copy of fast_float Date: Mon, 15 Nov 2021 19:25:02 -0500 Message-Id: <20211116002505.2324582-2-ppalka@redhat.com> X-Mailer: git-send-email 2.34.0 In-Reply-To: <20211116002505.2324582-1-ppalka@redhat.com> References: <20211116002505.2324582-1-ppalka@redhat.com> MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-16.0 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Patrick Palka via Gcc-patches From: Patrick Palka Reply-To: Patrick Palka Cc: libstdc++@gcc.gnu.org Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" 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 library chars_format and from_chars_result types libstdc++-v3/ChangeLog: * src/c++17/fast_float/LOCAL_PATCHES: Update. * src/c++17/fast_float/ascii_number.h, src/c++17/fast_float/bigint.h, src/c++17/fast_float/decimal_to_binary.h, src/c++17/fast_float/digit_comparison.h, src/c++17/fast_float/fast_float.h, src/c++17/fast_float/fast_table.h, src/c++17/fast_float/float_common.h, src/c++17/fast_float/parse_number.h: Apply local modifications. --- libstdc++-v3/src/c++17/fast_float/LOCAL_PATCHES | 1 + libstdc++-v3/src/c++17/fast_float/ascii_number.h | 11 +++-------- libstdc++-v3/src/c++17/fast_float/bigint.h | 5 ----- .../src/c++17/fast_float/decimal_to_binary.h | 6 ------ .../src/c++17/fast_float/digit_comparison.h | 5 ----- libstdc++-v3/src/c++17/fast_float/fast_float.h | 15 ++------------- libstdc++-v3/src/c++17/fast_float/fast_table.h | 2 -- libstdc++-v3/src/c++17/fast_float/float_common.h | 7 +------ libstdc++-v3/src/c++17/fast_float/parse_number.h | 5 ----- 9 files changed, 7 insertions(+), 50 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/ascii_number.h b/libstdc++-v3/src/c++17/fast_float/ascii_number.h index 3e6bb3e9ef3..c2f69326b2f 100644 --- a/libstdc++-v3/src/c++17/fast_float/ascii_number.h +++ b/libstdc++-v3/src/c++17/fast_float/ascii_number.h @@ -1,11 +1,6 @@ #ifndef FASTFLOAT_ASCII_NUMBER_H #define FASTFLOAT_ASCII_NUMBER_H -#include -#include -#include -#include - #include "float_common.h" namespace fast_float { @@ -144,7 +139,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; @@ -155,7 +150,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; } @@ -174,7 +169,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; diff --git a/libstdc++-v3/src/c++17/fast_float/bigint.h b/libstdc++-v3/src/c++17/fast_float/bigint.h index b56cb9b03b3..5c9552cab4c 100644 --- a/libstdc++-v3/src/c++17/fast_float/bigint.h +++ b/libstdc++-v3/src/c++17/fast_float/bigint.h @@ -1,11 +1,6 @@ #ifndef FASTFLOAT_BIGINT_H #define FASTFLOAT_BIGINT_H -#include -#include -#include -#include - #include "float_common.h" namespace fast_float { diff --git a/libstdc++-v3/src/c++17/fast_float/decimal_to_binary.h b/libstdc++-v3/src/c++17/fast_float/decimal_to_binary.h index 6da6c66a3ac..26343c4cd20 100644 --- a/libstdc++-v3/src/c++17/fast_float/decimal_to_binary.h +++ b/libstdc++-v3/src/c++17/fast_float/decimal_to_binary.h @@ -3,12 +3,6 @@ #include "float_common.h" #include "fast_table.h" -#include -#include -#include -#include -#include -#include namespace fast_float { diff --git a/libstdc++-v3/src/c++17/fast_float/digit_comparison.h b/libstdc++-v3/src/c++17/fast_float/digit_comparison.h index 7ffe874303b..4af465420c9 100644 --- a/libstdc++-v3/src/c++17/fast_float/digit_comparison.h +++ b/libstdc++-v3/src/c++17/fast_float/digit_comparison.h @@ -1,11 +1,6 @@ #ifndef FASTFLOAT_DIGIT_COMPARISON_H #define FASTFLOAT_DIGIT_COMPARISON_H -#include -#include -#include -#include - #include "float_common.h" #include "bigint.h" #include "ascii_number.h" 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 3c483803af3..a4b967f5dd7 100644 --- a/libstdc++-v3/src/c++17/fast_float/fast_float.h +++ b/libstdc++-v3/src/c++17/fast_float/fast_float.h @@ -1,21 +1,10 @@ #ifndef FASTFLOAT_FAST_FLOAT_H #define FASTFLOAT_FAST_FLOAT_H -#include - 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, diff --git a/libstdc++-v3/src/c++17/fast_float/fast_table.h b/libstdc++-v3/src/c++17/fast_float/fast_table.h index 5766274ca41..5e0faf71d6a 100644 --- a/libstdc++-v3/src/c++17/fast_float/fast_table.h +++ b/libstdc++-v3/src/c++17/fast_float/fast_table.h @@ -1,8 +1,6 @@ #ifndef FASTFLOAT_FAST_TABLE_H #define FASTFLOAT_FAST_TABLE_H -#include - namespace fast_float { /** diff --git a/libstdc++-v3/src/c++17/fast_float/float_common.h b/libstdc++-v3/src/c++17/fast_float/float_common.h index c8e7e4fc99e..e2b50cb3e69 100644 --- a/libstdc++-v3/src/c++17/fast_float/float_common.h +++ b/libstdc++-v3/src/c++17/fast_float/float_common.h @@ -1,11 +1,6 @@ #ifndef FASTFLOAT_FLOAT_COMMON_H #define FASTFLOAT_FLOAT_COMMON_H -#include -#include -#include -#include - #if (defined(__x86_64) || defined(__x86_64__) || defined(_M_X64) \ || defined(__amd64) || defined(__aarch64__) || defined(_M_ARM64) \ || defined(__MINGW64__) \ @@ -129,7 +124,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; diff --git a/libstdc++-v3/src/c++17/fast_float/parse_number.h b/libstdc++-v3/src/c++17/fast_float/parse_number.h index 62ae3b039e6..86dea2287b4 100644 --- a/libstdc++-v3/src/c++17/fast_float/parse_number.h +++ b/libstdc++-v3/src/c++17/fast_float/parse_number.h @@ -5,11 +5,6 @@ #include "decimal_to_binary.h" #include "digit_comparison.h" -#include -#include -#include -#include - namespace fast_float { From patchwork Tue Nov 16 00:25:03 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Patrick Palka X-Patchwork-Id: 47735 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 767C93857805 for ; Tue, 16 Nov 2021 00:27:49 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 767C93857805 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1637022469; bh=E318mzVmnKdBe78N3Tnsl73pfiG8c7f0KoyeIOlyKiI=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To:Cc: From; b=pafabT05OBOE2nyfQrWJ9hWq2Mtiwgm91krn2EqEiaTPjdH7Q0k8Gjmbro6beIE0i 1A4TsJ4k75bvSRy4sNRWK4G70E0Wk6e6k8RG2D3DjoAmech0xCOQuL6IH2OULt55v7 gfl48QaZvDZLQor7MUcBUJy33sHR1DuWRB+pf5Dk= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id 7FC23385800A for ; Tue, 16 Nov 2021 00:25:21 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 7FC23385800A Received: from mail-qk1-f197.google.com (mail-qk1-f197.google.com [209.85.222.197]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-110-AiSkFy6HNAu4AEMnlRaj2w-1; Mon, 15 Nov 2021 19:25:19 -0500 X-MC-Unique: AiSkFy6HNAu4AEMnlRaj2w-1 Received: by mail-qk1-f197.google.com with SMTP id bp17-20020a05620a459100b0045e893f2ed8so423108qkb.11 for ; Mon, 15 Nov 2021 16:25:19 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=E318mzVmnKdBe78N3Tnsl73pfiG8c7f0KoyeIOlyKiI=; b=hfr6fSLHgL2rI+jLkXnN6V6u5Lx5x9TxITpN2BprWnbfM+e3enOburR8J5TgjANAvm 8l6hO1/er85OayO0j+vV7SjskwsJzg0SXo9OhbWrKPNnomZspdA8H1wHRT2RsJEZETwJ UjOsCsQCGM0OmxK0umXUCrMerrtzdQQKOpxdjQ5xHVFRR/aeqsOhxl8jWmtPjwZuzL+1 CSMz14X/snYq6TxXEe4f2CimrKjygptzaeX8KtqlXX2PC4u7Lxil0xU4YRS5nPbiK83Y c224W4r1WGlBng3zjYFDo57xCa1y1dW/+lFH3VqrzHJuJhyAf258e2Ko0FrOZAaXR/U2 mFvg== X-Gm-Message-State: AOAM531BgLuX00Iv8DY8zm9Sp1+tOUcALMhv7i92DV4m7kAoij+MoGqz IgtBxskfs+iEMicIWA5q+IdRwJ0vwvRD6pilZaF384pkifBz80BqO/mNvW8I3pJVE9X8xNB1SJ9 riVkDmy5OSveuLwY8ZAZOa6/6/01m4ZQh9iibWBIW3yW6easlQtRNMi5OP2Mjh6qW/vM= X-Received: by 2002:ac8:5881:: with SMTP id t1mr3338419qta.414.1637022318268; Mon, 15 Nov 2021 16:25:18 -0800 (PST) X-Google-Smtp-Source: ABdhPJw9u/CiZv3eAlilayG54ULx9DBWSt/GvqivL5YcM1FN0vwjfSk1Pt3JzlyIf24AKBwCVKCjjg== X-Received: by 2002:ac8:5881:: with SMTP id t1mr3338386qta.414.1637022318000; Mon, 15 Nov 2021 16:25:18 -0800 (PST) Received: from localhost.localdomain (ool-457d493a.dyn.optonline.net. [69.125.73.58]) by smtp.gmail.com with ESMTPSA id j19sm7836545qkp.28.2021.11.15.16.25.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 15 Nov 2021 16:25:17 -0800 (PST) To: gcc-patches@gcc.gnu.org Subject: [PATCH 3/5] libstdc++: Adjust fast_float's over/underflow behavior for conformnace Date: Mon, 15 Nov 2021 19:25:03 -0500 Message-Id: <20211116002505.2324582-3-ppalka@redhat.com> X-Mailer: git-send-email 2.34.0 In-Reply-To: <20211116002505.2324582-1-ppalka@redhat.com> References: <20211116002505.2324582-1-ppalka@redhat.com> MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-15.7 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=unavailable autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Patrick Palka via Gcc-patches From: Patrick Palka Reply-To: Patrick Palka Cc: libstdc++@gcc.gnu.org Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" 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. libstdc++-v3/ChangeLog: * src/c++17/fast_float/LOCAL_PATCHES: Update. * src/c++17/fast_float/parse_number.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/parse_number.h | 10 ++++++++++ 2 files changed, 11 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/parse_number.h b/libstdc++-v3/src/c++17/fast_float/parse_number.h index 86dea2287b4..57b3585c2fe 100644 --- a/libstdc++-v3/src/c++17/fast_float/parse_number.h +++ b/libstdc++-v3/src/c++17/fast_float/parse_number.h @@ -99,6 +99,16 @@ from_chars_result from_chars_advanced(const char *first, const char *last, // If we called compute_float>(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(pns, am); } + + if((pns.mantissa != 0 && am.mantissa == 0 && am.power2 == 0) || am.power2 == binary_format::infinite_power()) { + // In case of over/underflow, return result_out_of_range and don't modify value, + // as per [charconv.from.chars]/1. + // + // If LWG 3081 gets adopted, then we'll need to call to_float in this case too. + answer.ec = std::errc::result_out_of_range; + return answer; + } + to_float(pns.negative, am, value); return answer; } From patchwork Tue Nov 16 00:25:04 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Patrick Palka X-Patchwork-Id: 47736 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 7EA773858027 for ; Tue, 16 Nov 2021 00:29:18 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 7EA773858027 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1637022558; bh=ZZGrpaRzoABiYDLrrZofupVpiFs3nigestqnXqjhzuo=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To:Cc: From; b=GnRMvIiAltWO8gp9Mng6zjchXyiEetf+ysC+8J2M2me6EemGg6MOZta1+DhsuhTdw VClwpR29AmNLgQuQNz5q4fiTkPZR3Ws1ucBbmlH6UtaWlBS3fbHwZ30djqiQRVp6IV 8+idlePZNLh9QXPXt/xikWQtvzRoQCr+eHRSKPyM= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id 0A4BE3857C4A for ; Tue, 16 Nov 2021 00:25:22 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 0A4BE3857C4A Received: from mail-qv1-f69.google.com (mail-qv1-f69.google.com [209.85.219.69]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-262-fs6J1IxdMoKsUxwuuF9c4A-1; Mon, 15 Nov 2021 19:25:20 -0500 X-MC-Unique: fs6J1IxdMoKsUxwuuF9c4A-1 Received: by mail-qv1-f69.google.com with SMTP id q9-20020ad45749000000b003bdeb0612c5so17657913qvx.8 for ; Mon, 15 Nov 2021 16:25:20 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=ZZGrpaRzoABiYDLrrZofupVpiFs3nigestqnXqjhzuo=; b=aVohiD7tZo47yPd3M6FtPpeVUIWV0CO0haPVnNeDB59RUKROCSprMp4SdjBcrKTkaS o3c/y/mOCjQaRJDPm4aI6h8fqYWgEFJTQEsTPhpt17CitlUoThg92iWGCUceNaSZ58jk B4GOwFr5f3kGGZm38jDl+W/SAGW78Ydq+iKq+dQb0vYcMFCVtPp3J32xYHrVlkC6gaQC /jpw0+c7GMze0f9k3jTf+E5mBVCkHUVuKhvJJL5zo27QBENcBs1n+W565beW+PjD05d0 BjslSLdepxzB4x64cxcTaB3Hym2N6WbtEWwDTqDL1Utcx1mS3Q20H1xsU5FYCoTuUMlF KMDw== X-Gm-Message-State: AOAM533NBhEfTlt+jm81ooZliTuZ8HHvwBBQ9dMnohjLuwJmcn9ZWQr5 jAZQk3pYX6LkxcY1kETUEKHUySjS9EQb3T25zZE11z75JGcT2GoBrwm5W31mjhE6yQ2xXZc9MeB PkBZso+KZfAiFINPMH5PvV57oW9CcgZo69Ho3FYmaXNklJVhtKRcx5YhoqqHvyTbEh2s= X-Received: by 2002:a37:9507:: with SMTP id x7mr2686730qkd.105.1637022320073; Mon, 15 Nov 2021 16:25:20 -0800 (PST) X-Google-Smtp-Source: ABdhPJzc4EXCl/KuCqKwswGkkkva6JDGEjItgqBQKw5vBNdm76+VVKkjgeuO3ChccecznSwWeWKjHw== X-Received: by 2002:a37:9507:: with SMTP id x7mr2686704qkd.105.1637022319786; Mon, 15 Nov 2021 16:25:19 -0800 (PST) Received: from localhost.localdomain (ool-457d493a.dyn.optonline.net. [69.125.73.58]) by smtp.gmail.com with ESMTPSA id j19sm7836545qkp.28.2021.11.15.16.25.18 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 15 Nov 2021 16:25:18 -0800 (PST) To: gcc-patches@gcc.gnu.org Subject: [PATCH 4/5] libstdc++: Use fast_float in std::from_chars for binary32/64 Date: Mon, 15 Nov 2021 19:25:04 -0500 Message-Id: <20211116002505.2324582-4-ppalka@redhat.com> X-Mailer: git-send-email 2.34.0 In-Reply-To: <20211116002505.2324582-1-ppalka@redhat.com> References: <20211116002505.2324582-1-ppalka@redhat.com> MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-15.8 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_NUMSUBJECT, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=unavailable autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Patrick Palka via Gcc-patches From: Patrick Palka Reply-To: Patrick Palka Cc: libstdc++@gcc.gnu.org Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" This makes our std::from_chars implementation use fast_float for parsing chars_format::scientific/fixed/general parsing into binary32/64 values. For chars_format::hex (and long double) 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 | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/libstdc++-v3/src/c++17/floating_from_chars.cc b/libstdc++-v3/src/c++17/floating_from_chars.cc index aa074869872..13834f54d38 100644 --- a/libstdc++-v3/src/c++17/floating_from_chars.cc +++ b/libstdc++-v3/src/c++17/floating_from_chars.cc @@ -34,6 +34,7 @@ #include #include #include +#include #include #include #include @@ -52,6 +53,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) { @@ -406,6 +419,11 @@ from_chars_result from_chars(const char* first, const char* last, float& value, chars_format fmt) noexcept { +#if USE_LIB_FAST_FLOAT + if (fmt != chars_format::hex) + return fast_float::from_chars(first, last, value, fmt); +#endif + errc ec = errc::invalid_argument; #if _GLIBCXX_USE_CXX11_ABI buffer_resource mr; @@ -432,6 +450,11 @@ from_chars_result from_chars(const char* first, const char* last, double& value, chars_format fmt) noexcept { +#if USE_LIB_FAST_FLOAT + if (fmt != chars_format::hex) + return fast_float::from_chars(first, last, value, fmt); +#endif + errc ec = errc::invalid_argument; #if _GLIBCXX_USE_CXX11_ABI buffer_resource mr; From patchwork Tue Nov 16 00:25:05 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Patrick Palka X-Patchwork-Id: 47738 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 9C49B3857404 for ; Tue, 16 Nov 2021 00:33:02 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 9C49B3857404 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1637022782; bh=r8G/xK+KOoPpoOduUJdo7sYA5aQ8CCX/N+qbfKnmiVE=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To:Cc: From; b=HHMqOZt4uCJBnkQF3RvfjDmOY/eP9wdWhndE7miiYyX9F+D3VbRi/Amh6qGtL+Gol bbEh4djwBSbK2OvD3i0C++cMBnxSBpKEHKaIQqPEfv27LGjz3/lIIYabZq9rU20ckP VqhoafVVegrbY+N0l0XM8HS68YCd9lDwF4XJ7quc= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id 409173857C79 for ; Tue, 16 Nov 2021 00:25:29 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 409173857C79 Received: from mail-qv1-f70.google.com (mail-qv1-f70.google.com [209.85.219.70]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-288--uZc88mEMl2Q5sYJIWlKJQ-1; Mon, 15 Nov 2021 19:25:24 -0500 X-MC-Unique: -uZc88mEMl2Q5sYJIWlKJQ-1 Received: by mail-qv1-f70.google.com with SMTP id n4-20020a0ce944000000b003bdcabf4cdfso17517926qvo.16 for ; Mon, 15 Nov 2021 16:25:24 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=r8G/xK+KOoPpoOduUJdo7sYA5aQ8CCX/N+qbfKnmiVE=; b=XloDRvAlNVV6AZe/JWxNM8IcQGnOVk9lrmHrx5p38Wptf2IR/w7OtBJpJadjcduZG+ QWvr4nZk8b3RG+yLA+NXqyoYxJVP23rAO/d5WaM31sO8LAEWZohedvl0zcxmx4AvLMKU Zu9m4Uclo40AngB/UMJwZBc/vj1c84FZwBZ4ep/g6FI61iCVQtAF0Yl5fCyL3Rp+BbnM z4lomEU0Kf0ySJciOkLHwArNhd0ev2OQk96c9IyVvn6Lb2lrxGQJ+GfcnS75rs0KrHZg 6wH8MISpamVDBmZDSPU/+bnImAW3tXAPawtRcmxiQ6T72+yfRAiwaVSR20sef/J9ZQxp lnBg== X-Gm-Message-State: AOAM5317keRBCPApWdOG0swpQPzoIgCUgt4gI9nH3aEs5tkIRBd/2K97 vNHfRs5mhy4B53veoCtB8sng+l0JBnWIa/1MSTr+Y94nmcL+LRxV85lxBQi6y8wLS0PG0d0h8IN E86vMd84raHQD32Rb0hgdLz3zk5wqq4u9l5OCMyJcmmGTwvDUoDid4DyOPPEgBaS9mJw= X-Received: by 2002:a05:620a:1335:: with SMTP id p21mr2735090qkj.182.1637022322417; Mon, 15 Nov 2021 16:25:22 -0800 (PST) X-Google-Smtp-Source: ABdhPJy6+/Lm+qC7ZmCbac/wkW/zN70khlk8hq2KlMz/Zya4IL6G4sEL89GeRHjQ7DmiMMQN4WBPuA== X-Received: by 2002:a05:620a:1335:: with SMTP id p21mr2734998qkj.182.1637022321413; Mon, 15 Nov 2021 16:25:21 -0800 (PST) Received: from localhost.localdomain (ool-457d493a.dyn.optonline.net. [69.125.73.58]) by smtp.gmail.com with ESMTPSA id j19sm7836545qkp.28.2021.11.15.16.25.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 15 Nov 2021 16:25:20 -0800 (PST) To: gcc-patches@gcc.gnu.org Subject: [PATCH 5/5] libstdc++: Import MSVC floating-point std::from_chars testcases Date: Mon, 15 Nov 2021 19:25:05 -0500 Message-Id: <20211116002505.2324582-5-ppalka@redhat.com> X-Mailer: git-send-email 2.34.0 In-Reply-To: <20211116002505.2324582-1-ppalka@redhat.com> References: <20211116002505.2324582-1-ppalka@redhat.com> MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-15.9 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_LOTSOFHASH, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Patrick Palka via Gcc-patches From: Patrick Palka Reply-To: Patrick Palka Cc: libstdc++@gcc.gnu.org Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" All testcases are added, but we temporarily disable the chars_format::hex testcases due to quirks in various strtod implementations observed during testing (e.g. ERANGE not being signalled in case of overflow, and improper rounding of subnormals) which would otherwise cause the tests to be flaky. 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 | 1680 +++++++++++++++++ .../testsuite/20_util/from_chars/float.cc | 296 +++ 2 files changed, 1976 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..4dc1ca17865 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/from_chars/double.cc @@ -0,0 +1,1680 @@ +// 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 + +#include +#include +#include + +using namespace std; + +inline constexpr double double_inf = numeric_limits::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 ": 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 ": [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 ": hex from_chars(\"0.fffffffffffff8p-1022\") is incorrect" + // Test cases for values close to std::numeric_limits::min() and std::numeric_limits::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) + { + if (fmt == chars_format::hex) + // FIXME: Due to quirks in some strtod implementations, the hex + // testcases are currently disabled until we implement hex parsing in a + // more portable way that doesn't go through the target libc's strtod. + continue; + + 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..ba39b7e16a1 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/from_chars/float.cc @@ -0,0 +1,296 @@ +// 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 + +#include +#include +#include + +using namespace std; + +inline constexpr float float_inf = numeric_limits::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 ": 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 ": [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 ": hex from_chars(\"0.fffffffffffff8p-1022\") is incorrect" + // Test cases for values close to std::numeric_limits::min() and std::numeric_limits::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) + { + if (fmt == chars_format::hex) + // FIXME: Due to quirks in some strtod implementations, the hex + // testcases are currently disabled until we implement hex parsing in a + // more portable way that doesn't go through the target libc's strtod. + continue; + + 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 ); + } +}