Merge branch 'emg-schwab/cmake_install_targets' of https://github.com/georg-emg/fast_float into cmake_install_targets

2025-12-07 01:06:48 +08:00 · 2021-02-09 09:51:22 +01:00 · 2021-02-09 09:51:22 +01:00 · dfa304a698
commit dfa304a698
parent f1681745e4 6c27435fbc
9 changed files with 220 additions and 142 deletions
--- a/.github/workflows/mingw-ci.yml
+++ b/.github/workflows/mingw-ci.yml
@ -1,49 +0,0 @@
-name: MinGW32-CI
-
-on: [push, pull_request]
-
-# Important: scoop will either install 32-bit GCC or 64-bit GCC, not both.
-
-# It is important to build static libraries because cmake is not smart enough under Windows/mingw to take care of the path. So
-# with a dynamic library, you could get failures due to the fact that the EXE can't find its DLL.
-
-jobs:
-  ci:
-    name: windows-gcc
-    runs-on: windows-2016
-
-    env:
-      CMAKE_GENERATOR: Ninja
-      CC: gcc
-      CXX: g++
-
-    steps: # To reproduce what is below, start a powershell with administrative rights, using scoop *is* a good idea
-      - uses: actions/checkout@v2
-
-      - uses: actions/cache@v2 # we cache the scoop setup with 32-bit GCC
-        id: cache
-        with:
-          path: |
-            C:\ProgramData\scoop
-          key: scoop32 # static key: should be good forever
-      - name: Setup Windows # This should almost never run if the cache works.
-        if: steps.cache.outputs.cache-hit != 'true'
-        shell: powershell
-        run: |
-          Invoke-Expression (New-Object System.Net.WebClient).DownloadString('https://get.scoop.sh')
-          scoop install sudo --global
-          sudo scoop install git --global
-          sudo scoop install ninja --global
-          sudo scoop install cmake --global
-          sudo scoop install gcc --arch 32bit --global
-          $env:path
-          Write-Host 'Everything has been installed, you are good!'
-      - name: Build and Test 32-bit x86
-        shell: powershell
-        run: |
-          $ENV:PATH="C:\ProgramData\scoop\shims;C:\ProgramData\scoop\apps\gcc\current\bin;C:\ProgramData\scoop\apps\ninja\current;$ENV:PATH"
-          mkdir build32
-          cd build32
-          cmake  -DFASTFLOAT_TEST=ON ..
-          cmake --build .   --verbose
-          ctest -j4 --output-on-failure -R basictest
--- a/.github/workflows/mingw64-ci.yml
+++ b/.github/workflows/mingw64-ci.yml
@ -1,49 +0,0 @@
-name: MinGW64-CI
-
-on: [push, pull_request]
-
-# Important: scoop will either install 32-bit GCC or 64-bit GCC, not both.
-
-# It is important to build static libraries because cmake is not smart enough under Windows/mingw to take care of the path. So
-# with a dynamic library, you could get failures due to the fact that the EXE can't find its DLL.
-
-jobs:
-  ci:
-    name: windows-gcc
-    runs-on: windows-2016
-
-    env:
-      CMAKE_GENERATOR: Ninja
-      CC: gcc
-      CXX: g++
-
-    steps: # To reproduce what is below, start a powershell with administrative rights, using scoop *is* a good idea
-      - uses: actions/checkout@v2
-
-      - uses: actions/cache@v2 # we cache the scoop setup with 64-bit GCC
-        id: cache
-        with:
-          path: |
-            C:\ProgramData\scoop
-          key: scoop64 # static key: should be good forever
-      - name: Setup Windows # This should almost never run if the cache works.
-        if: steps.cache.outputs.cache-hit != 'true'
-        shell: powershell
-        run: |
-          Invoke-Expression (New-Object System.Net.WebClient).DownloadString('https://get.scoop.sh')
-          scoop install sudo --global
-          sudo scoop install git --global
-          sudo scoop install ninja --global
-          sudo scoop install cmake --global
-          sudo scoop install gcc --arch 64bit --global
-          $env:path
-          Write-Host 'Everything has been installed, you are good!'
-      - name: Build and Test 64-bit x64
-        shell: powershell
-        run: |
-          $ENV:PATH="C:\ProgramData\scoop\shims;C:\ProgramData\scoop\apps\gcc\current\bin;C:\ProgramData\scoop\apps\ninja\current;$ENV:PATH"
-          mkdir build64
-          cd build64
-          cmake  -DFASTFLOAT_TEST=ON ..
-          cmake --build .   --verbose
-          ctest -j4 --output-on-failure -R basictest
--- a/.github/workflows/ubuntu18.yml
+++ b/.github/workflows/ubuntu18.yml
@ -9,21 +9,22 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - {cxx: -DCMAKE_CXX_COMPILER=g++-5, arch:                         }
-          - {cxx: -DCMAKE_CXX_COMPILER=g++-6, arch:                         }
+          # Legacy/x86 compilers cause CI failures.
+          #- {cxx: -DCMAKE_CXX_COMPILER=g++-5, arch:                         }
+          #- {cxx: -DCMAKE_CXX_COMPILER=g++-6, arch:                         }
          - {cxx:                           , arch:                         } # default=gcc7
-          - {cxx:                           , arch: -DCMAKE_CXX_FLAGS="-m32"} # default=gcc7
+          #- {cxx:                           , arch: -DCMAKE_CXX_FLAGS="-m32"} # default=gcc7
    steps:
      - uses: actions/checkout@v2
      - name: Setup cmake
        uses: jwlawson/actions-setup-cmake@v1.4
        with:
          cmake-version: '3.11.x'
-      - name: Install older compilers
-        run: |
-          sudo -E dpkg --add-architecture i386
-          sudo -E apt-get update
-          sudo -E apt-get install -y --force-yes g++-5 g++-6 g++-5-multilib g++-6-multilib g++-multilib linux-libc-dev:i386 libc6:i386 libc6-dev:i386 libc6-dbg:i386
+      #- name: Install older compilers
+      #  run: |
+      #    sudo -E dpkg --add-architecture i386
+      #    sudo -E apt-get update
+      #    sudo -E apt-get install -y --force-yes g++-5 g++-6 g++-5-multilib g++-6-multilib g++-multilib linux-libc-dev:i386 libc6:i386 libc6-dev:i386 libc6-dbg:i386
      - name: Prepare build dir
        run: mkdir build
      - name: Configure
--- a/.github/workflows/ubuntu20.yml
+++ b/.github/workflows/ubuntu20.yml
@ -9,20 +9,21 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - {cxx: -DCMAKE_CXX_COMPILER=g++-8, arch:                         }
+          # Legacy/x86 compilers cause CI failures.
+          #- {cxx: -DCMAKE_CXX_COMPILER=g++-8, arch:                         }
          - {cxx:                           , arch:                         } # default=gcc9
-          - {cxx:                           , arch: -DCMAKE_CXX_FLAGS="-m32"} # default=gcc9
+          #- {cxx:                           , arch: -DCMAKE_CXX_FLAGS="-m32"} # default=gcc9
    steps:
      - uses: actions/checkout@v2
      - name: Setup cmake
        uses: jwlawson/actions-setup-cmake@v1.4
        with:
          cmake-version: '3.11.x'
-      - name: install older compilers
-        run: |
-          sudo -E dpkg --add-architecture i386
-          sudo -E apt-get update
-          sudo -E apt-get install -y g++-8 g++-8-multilib g++-multilib linux-libc-dev:i386 libc6:i386 libc6-dev:i386 libc6-dbg:i386
+      #- name: install older compilers
+      #  run: |
+      #    sudo -E dpkg --add-architecture i386
+      #    sudo -E apt-get update
+      #    sudo -E apt-get install -y g++-8 g++-8-multilib g++-multilib linux-libc-dev:i386 libc6:i386 libc6-dev:i386 libc6-dbg:i386
      - name: Prepare build dir
        run: mkdir build
      - name: Configure
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -1,10 +1,17 @@
 cmake_minimum_required(VERSION 3.9)

 project(fast_float VERSION 0.7.0 LANGUAGES CXX)
-set(CMAKE_CXX_STANDARD 11)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-
+option(FASTFLOAT_TEST "Enable tests" OFF)
+if(FASTFLOAT_TEST)
+  set(CMAKE_CXX_STANDARD 17)
+  set(CMAKE_CXX_STANDARD_REQUIRED OFF)
+  enable_testing()
+  add_subdirectory(tests)
+else(FASTFLOAT_TEST)
+  set(CMAKE_CXX_STANDARD 11)
+  set(CMAKE_CXX_STANDARD_REQUIRED ON)
+  message(STATUS "Tests are disabled. Set FASTFLOAT_TEST to ON to run tests.")
+endif(FASTFLOAT_TEST)

 option(FASTFLOAT_SANITIZE "Sanitize addresses" OFF)

@ -33,11 +40,6 @@ if(FASTFLOAT_SANITIZE)
  endif()
 endif()

-if(FASTFLOAT_TEST)
-  enable_testing()
-  add_subdirectory(tests)
-endif(FASTFLOAT_TEST)
-
 include(CMakePackageConfigHelpers)

 set(FASTFLOAT_VERSION_CONFIG "${CMAKE_CURRENT_BINARY_DIR}/module/fast_float-config-version.cmake")
--- a/README.md
+++ b/README.md
@ -66,6 +66,17 @@ The default is  `fast_float::chars_format::general` which allows both `fixed` an

 We support Visual Studio, macOS, Linux, freeBSD. We support big and little endian. We support 32-bit and 64-bit systems.

+## Reference
+
+- Daniel Lemire, [Number Parsing at a Gigabyte per Second](https://arxiv.org/abs/2101.11408), arXiv:2101.11408
+
+
+## Other programming languages
+
+- [There is an R binding](https://github.com/eddelbuettel/rcppfastfloat) called `rcppfastfloat`.
+- [There is a Rust port of the fast_float library](https://github.com/aldanor/fast-float-rust/) called `fast-float-rust`.
+
+
 ## Relation With Other Work

 The fast_float library provides a performance similar to that of the [fast_double_parser](https://github.com/lemire/fast_double_parser) library but using an updated algorithm reworked from the ground up, and while offering an API more in line with the expectations of C++ programmers. The fast_double_parser library is part of the [Microsoft LightGBM machine-learning framework](https://github.com/microsoft/LightGBM).
--- a/include/fast_float/ascii_number.h
+++ b/include/fast_float/ascii_number.h
@ -249,6 +249,26 @@ fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend) n
    }
    answer.decimal_point = int32_t(first_after_period - p);
  }
+  // We want num_digits to be the number of significant digits, excluding
+  // leading *and* trailing zeros! Otherwise the truncated flag later is
+  // going to be misleading.
+  if(answer.num_digits > 0) {
+    // We potentially need the answer.num_digits > 0 guard because we
+    // prune leading zeros. So with answer.num_digits > 0, we know that
+    // we have at least one non-zero digit.
+    const char *preverse = p - 1;
+    int32_t trailing_zeros = 0;
+    while ((*preverse == '0') || (*preverse == '.')) {
+      if(*preverse == '0') { trailing_zeros++; };
+      --preverse;
+    }
+    answer.decimal_point += int32_t(answer.num_digits);
+    answer.num_digits -= uint32_t(trailing_zeros);
+  }
+  if(answer.num_digits > max_digits) {
+    answer.truncated = true;
+    answer.num_digits = max_digits;
+  }
  if ((p != pend) && (('e' == *p) || ('E' == *p))) {
    ++p;
    bool neg_exp = false;
@ -268,11 +288,6 @@ fastfloat_really_inline decimal parse_decimal(const char *p, const char *pend) n
    }
    answer.decimal_point += (neg_exp ? -exp_number : exp_number);
  }
-  answer.decimal_point += int32_t(answer.num_digits);
-  if(answer.num_digits > max_digits) {
-    answer.truncated = true;
-    answer.num_digits = max_digits;
-  }
  // In very rare cases, we may have fewer than 19 digits, we want to be able to reliably
  // assume that all digits up to max_digit_without_overflow have been initialized.
  for(uint32_t i = answer.num_digits; i < max_digit_without_overflow; i++) { answer.digits[i] = 0; }
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@ -7,6 +7,11 @@ include(FetchContent)
 FetchContent_Declare(doctest
  GIT_REPOSITORY https://github.com/onqtam/doctest.git
  GIT_TAG 2.4.1)
+FetchContent_Declare(supplemental_test_files
+  GIT_REPOSITORY https://github.com/fastfloat/supplemental_test_files.git
+  GIT_TAG origin/main)
+
+

 # FetchContent_MakeAvailable() was only introduced in 3.14
 # https://cmake.org/cmake/help/v3.14/release/3.14.html#modules
@ -16,8 +21,15 @@ if(NOT doctest_POPULATED)
  FetchContent_Populate(doctest)
  add_subdirectory(${doctest_SOURCE_DIR} ${doctest_BINARY_DIR})
 endif()
-
-
+FetchContent_GetProperties(supplemental_test_files)
+if(NOT supplemental_test_files_POPULATED)
+  message(STATUS "Tests enabled. Retrieving test files.")
+  FetchContent_Populate(supplemental_test_files)
+  message(STATUS "Test files retrieved.")
+  add_subdirectory(${supplemental_test_files_SOURCE_DIR} ${supplemental_test_files_BINARY_DIR})
+endif()
+add_library(supplemental-data INTERFACE)
+target_compile_definitions(supplemental-data INTERFACE SUPPLEMENTAL_TEST_DATA_DIR="${supplemental_test_files_BINARY_DIR}/data")
 function(fast_float_add_cpp_test TEST_NAME)
    add_executable(${TEST_NAME} ${TEST_NAME}.cpp)
    add_test(${TEST_NAME} ${TEST_NAME})
@ -25,18 +37,28 @@ function(fast_float_add_cpp_test TEST_NAME)
      target_compile_options(${TEST_NAME} PUBLIC -Werror -Wall -Wextra -Weffc++)
      target_compile_options(${TEST_NAME} PUBLIC -Wsign-compare -Wshadow -Wwrite-strings -Wpointer-arith -Winit-self -Wconversion -Wsign-conversion)
    endif()
-    target_link_libraries(${TEST_NAME} PUBLIC fast_float doctest)
+    target_link_libraries(${TEST_NAME} PUBLIC fast_float doctest supplemental-data)
 endfunction(fast_float_add_cpp_test)
-fast_float_add_cpp_test(powersoffive_hardround)
-fast_float_add_cpp_test(short_random_string)
-fast_float_add_cpp_test(exhaustive32_midpoint)
-fast_float_add_cpp_test(random_string)
-fast_float_add_cpp_test(string_test)
-fast_float_add_cpp_test(exhaustive32)
-fast_float_add_cpp_test(exhaustive32_64)
-fast_float_add_cpp_test(long_exhaustive32)
-fast_float_add_cpp_test(long_exhaustive32_64)
-fast_float_add_cpp_test(long_random64)
-fast_float_add_cpp_test(random64)
-fast_float_add_cpp_test(basictest)
+
+
 fast_float_add_cpp_test(example_test)
+fast_float_add_cpp_test(basictest)
+
+
+
+option(FASTFLOAT_EXHAUSTIVE "Exhaustive tests" OFF)
+
+if (FASTFLOAT_EXHAUSTIVE)
+  fast_float_add_cpp_test(powersoffive_hardround)
+  fast_float_add_cpp_test(short_random_string)
+  fast_float_add_cpp_test(exhaustive32_midpoint)
+  fast_float_add_cpp_test(random_string)
+  fast_float_add_cpp_test(string_test)
+  fast_float_add_cpp_test(exhaustive32)
+  fast_float_add_cpp_test(exhaustive32_64)
+  fast_float_add_cpp_test(long_exhaustive32)
+  fast_float_add_cpp_test(long_exhaustive32_64)
+  fast_float_add_cpp_test(long_random64)
+  fast_float_add_cpp_test(random64)
+endif(FASTFLOAT_EXHAUSTIVE)
+
--- a/tests/basictest.cpp
+++ b/tests/basictest.cpp
@ -4,6 +4,110 @@

 #include "fast_float/fast_float.h"
 #include <iomanip>
+#include <string>
+
+#ifndef SUPPLEMENTAL_TEST_DATA_DIR
+#define SUPPLEMENTAL_TEST_DATA_DIR "data/"
+#endif
+
+#ifndef __cplusplus
+#error fastfloat requires a C++ compiler
+#endif
+
+#ifndef FASTFLOAT_CPLUSPLUS
+#if defined(_MSVC_LANG) && !defined(__clang__)
+#define FASTFLOAT_CPLUSPLUS (_MSC_VER == 1900 ? 201103L : _MSVC_LANG)
+#else
+#define FASTFLOAT_CPLUSPLUS __cplusplus
+#endif
+#endif
+
+
+#if defined(__CYGWIN__) || defined(__MINGW32__) || defined(__MINGW64__) || defined(sun) || defined(__sun)
+#define FASTFLOAT_ODDPLATFORM 1
+#endif
+#if defined __has_include
+#if __has_include (<filesystem>)
+#else
+// filesystem is not available
+#define FASTFLOAT_ODDPLATFORM 1
+#endif
+#else
+// __has_include is not available
+#define FASTFLOAT_ODDPLATFORM 1
+#endif
+
+// C++ 17 because it is otherwise annoying to browse all files in a directory.
+// We also only run these tests on little endian systems.
+#if (FASTFLOAT_CPLUSPLUS >= 201703L) && (FASTFLOAT_IS_BIG_ENDIAN == 0) && !defined(FASTFLOAT_ODDPLATFORM)
+
+#include <iostream>
+#include <filesystem>
+#include <charconv>
+
+// return true on succcess
+bool check_file(std::string file_name) {
+  std::cout << "Checking " << file_name << std::endl;
+  size_t number{0};
+  std::fstream newfile(file_name, std::ios::in);
+  if (newfile.is_open()) {
+    std::string str;
+    while (std::getline(newfile, str)) {
+      if (str.size() > 0) {
+        // Read 32-bit hex
+        uint32_t float32;
+        auto r32 = std::from_chars(str.data() + 5, str.data() + str.size(),
+                                   float32, 16);
+        if(r32.ec != std::errc()) { std::cerr << "32-bit parsing failure\n"; return false; }
+        // Read 64-bit hex
+        uint64_t float64;
+        auto r64 = std::from_chars(str.data() + 14, str.data() + str.size(),
+                                   float64, 16);
+        if(r64.ec != std::errc()) { std::cerr << "64-bit parsing failure\n"; return false; }
+        // The string to parse:
+        const char *number_string = str.data() + 31;
+        const char *end_of_string = str.data() + str.size();
+        // Parse as 32-bit float
+        float parsed_32;
+        auto fast_float_r32 = fast_float::from_chars(number_string, end_of_string, parsed_32);
+        if(fast_float_r32.ec != std::errc()) { std::cerr << "parsing failure\n"; return false; }
+        // Parse as 64-bit float
+        double parsed_64;
+        auto fast_float_r64 = fast_float::from_chars(number_string, end_of_string, parsed_64);
+        if(fast_float_r64.ec != std::errc()) { std::cerr << "parsing failure\n"; return false; }
+        // Convert the floats to unsigned ints.
+        uint32_t float32_parsed;
+        uint64_t float64_parsed;
+        ::memcpy(&float32_parsed, &parsed_32, sizeof(parsed_32));
+        ::memcpy(&float64_parsed, &parsed_64, sizeof(parsed_64));
+        // Compare with expected results
+        if (float32_parsed != float32) {
+          std::cout << "bad 32 " << str << std::endl;
+          return false;
+        }
+        if (float64_parsed != float64) {
+          std::cout << "bad 64 " << str << std::endl;
+          return false;
+        }
+        number++;
+      }
+    }
+    std::cout << "checked " << std::defaultfloat << number << " values" << std::endl;
+    newfile.close(); // close the file object
+  } else {
+    std::cout << "Could not read  " << file_name << std::endl;
+    return false;
+  }
+  return true;
+}
+
+TEST_CASE("supplemental") {
+    std::string path = SUPPLEMENTAL_TEST_DATA_DIR;
+    for (const auto & entry : std::filesystem::directory_iterator(path)) {
+        CHECK(check_file(entry.path().string()));
+    }
+}
+#endif


 TEST_CASE("leading_zeroes") {
@ -238,6 +342,12 @@ uint64_t get_mantissa(double f) {
 }


+std::string append_zeros(std::string str, size_t number_of_zeros) {
+  std::string answer(str);
+  for(size_t i = 0; i < number_of_zeros; i++) { answer += "0"; }
+  return answer;
+}
+
 template<class T>
 void basic_test(std::string str, T expected) {
  T actual;
@ -288,6 +398,12 @@ TEST_CASE("64bit.inf") {
 }

 TEST_CASE("64bit.general") {
+  verify("9007199254740993.0", 0x1p+53);
+  verify("860228122.6654514319E+90", 0x1.92bb20990715fp+328);
+  verify(append_zeros("9007199254740993.0",1000), 0x1p+53);
+  verify("10000000000000000000", 0x1.158e460913dp+63);
+  verify("10000000000000000000000000000001000000000000", 0x1.cb2d6f618c879p+142);
+  verify("10000000000000000000000000000000000000000001", 0x1.cb2d6f618c879p+142);
  verify("1.1920928955078125e-07", 1.1920928955078125e-07);
  verify("9355950000000000000.00000000000000000000000000000000001844674407370955161600000184467440737095516161844674407370955161407370955161618446744073709551616000184467440737095516166000001844674407370955161618446744073709551614073709551616184467440737095516160001844674407370955161601844674407370955674451616184467440737095516140737095516161844674407370955161600018446744073709551616018446744073709551611616000184467440737095001844674407370955161600184467440737095516160018446744073709551168164467440737095516160001844073709551616018446744073709551616184467440737095516160001844674407536910751601611616000184467440737095001844674407370955161600184467440737095516160018446744073709551616184467440737095516160001844955161618446744073709551616000184467440753691075160018446744073709",0x1.03ae05e8fca1cp+63);
  verify("-0",-0.0);
@ -355,6 +471,14 @@ TEST_CASE("32bit.inf") {
 }

 TEST_CASE("32bit.general") {
+  verify("1.1754941406275178592461758986628081843312458647327962400313859427181746759860647699724722770042717456817626953125", 0x1.2ced3p+0f);
+  verify("1.1754941406275178592461758986628081843312458647327962400313859427181746759860647699724722770042717456817626953125e-38", 0x1.fffff8p-127f);
+  verify(append_zeros("1.1754941406275178592461758986628081843312458647327962400313859427181746759860647699724722770042717456817626953125",655), 0x1.2ced3p+0f);
+  verify(append_zeros("1.1754941406275178592461758986628081843312458647327962400313859427181746759860647699724722770042717456817626953125",656), 0x1.2ced3p+0f);
+  verify(append_zeros("1.1754941406275178592461758986628081843312458647327962400313859427181746759860647699724722770042717456817626953125",1000), 0x1.2ced3p+0f);
+  verify(append_zeros("1.1754941406275178592461758986628081843312458647327962400313859427181746759860647699724722770042717456817626953125",655) + "e-38", 0x1.fffff8p-127f);
+  verify(append_zeros("1.1754941406275178592461758986628081843312458647327962400313859427181746759860647699724722770042717456817626953125",656) + "e-38", 0x1.fffff8p-127f);
+  verify(append_zeros("1.1754941406275178592461758986628081843312458647327962400313859427181746759860647699724722770042717456817626953125",1000) + "e-38", 0x1.fffff8p-127f);
  verify32(1.00000006e+09f);
  verify32(1.4012984643e-45f);
  verify32(1.1754942107e-38f);