Merge pull request #30 from fastfloat/float64

adding 64-bit float checks + fix to netlib

Author: lemire

README.md

@@ -33,6 +33,9 @@ cmake --build build
 ./build/benchmarks/benchmark 
 ```
 
+Some functionality might be disabled under some systems. For example, under macOS with
+libc++, some tests might be omitted because it does not yet fully support C++17.
+
 We also support Visual Studio, please refer to the cmake documentation.
 
 You may use docker to run these benchmarks easily on a variety of platforms: see https://github.com/lemire/docker_programming_station
@@ -64,12 +67,31 @@ Serialize strings generated from floats in (0,1):
 ## Exhaustive 32-bit check
 
 We also include an exhaustive check of all 32-bit floats, to verify
-that we can produce the shortest string representation.
+that we can produce the shortest string representation (measured by
+the number of significant digits).
+
+Under Linux, you may run the following check:
 
 ```
+cmake -B build .
+cmake --build build --config Release
 ./build/benchmarks/exhaustivefloat32
 ```
 
+## Thorough 64-bit check
+
+We also include a thorough check of many 64-bit floats, to verify
+that we can produce the shortest string representation (measured by 
+the number of significant digits).
+
+Under Linux, you may run the following check:
+
+```
+cmake -B build .
+cmake --build build --config Release
+./build/benchmarks/thoroughfloat64
+```
+
 ## Other existing benchmarks
 
 - [dtoa Benchmark](https://github.com/miloyip/dtoa-benchmark)

benchmarks/CMakeLists.txt

@@ -93,6 +93,14 @@ if(TO_CHARS_OK AND FROM_CHARS_OK)
     add_executable(exhaustivefloat32
         exhaustivefloat32.cpp
     )
+
     target_link_libraries(exhaustivefloat32 PUBLIC benchmark_deps)
+    add_executable(thoroughfloat64
+        thoroughfloat64.cpp
+    )
+    set(THOROUGH_DATA_FILE "${CMAKE_SOURCE_DIR}/data/thoroughnumbers.txt")
+    target_compile_definitions(thoroughfloat64 PRIVATE THOROUGH_DATA_FILE="${THOROUGH_DATA_FILE}")
+
+    target_link_libraries(thoroughfloat64 PUBLIC benchmark_deps)
 endif(TO_CHARS_OK AND FROM_CHARS_OK)
 

benchmarks/algorithms.h

@@ -128,6 +128,7 @@ int netlib(T d, std::span<char>& buffer) {
   int decpt, sign;
   char* rve;
   char* result = dtoa(d, 0, 0, &decpt, &sign, &rve);
+
   if (result) {
     int i = 0;
     if (sign)
@@ -141,17 +142,40 @@ int netlib(T d, std::span<char>& buffer) {
       // Number is < 1 (e.g., 0.000123)
       buffer[i++] = '0';
       buffer[i++] = '.';
-      std::fill_n(buffer.data() + i, -decpt, '0'); // Add leading zeros
-      i += -decpt;
+      // Adding lots of zeroes so can create a really large output:
+      //std::fill_n(buffer.data() + i, -decpt, '0'); // Add leading zeros
+      //i += -decpt;
     }
-
+    auto write_exponent = [&buffer, &i](int value) {
+      if (value >= 100) {
+          buffer[i++] = '0' + value / 100;
+          value %= 100;
+          buffer[i++] = '0' + value / 10;
+          value %= 10;
+          buffer[i++] = '0' + value;
+      } else if (value >= 10) {
+          buffer[i++] = '0' + value / 10;
+          value %= 10;
+          buffer[i++] = '0' + value;
+      } else {
+          buffer[i++] = '0' + value;
+      }
+  };
     // Fractional part (if any remaining digits)
     const int remaining_digits = rve - (result + std::max(0, decpt));
     if (remaining_digits > 0) {
       if (decpt > 0)
         buffer[i++] = '.';
       std::copy_n(result + std::max(0, decpt), remaining_digits, buffer.data() + i);
       i += remaining_digits;
+      if(decpt < 0) {
+        buffer[i++] = 'E';
+        buffer[i++] = '-';
+        write_exponent(-decpt);
+      }
+    } else if (remaining_digits < 0) {
+      buffer[i++] = 'E';
+      write_exponent(-remaining_digits);
     }
 
     freedtoa(result);

benchmarks/exhaustivefloat32.cpp

@@ -117,13 +117,13 @@ void run_exhaustive32(bool errol) {
       }
       if(*backRef != d) {
         incorrect = true;
-        fmt::print(" ref mismatch: d = {}, backRef = {}", d, *backRef);
+        fmt::print(" ref mismatch: d = {}, backRef = {}; svRef = {}, svAlgo = {}", float_to_hex(d), *backRef, svRef, svAlgo);
         fflush(stdout);
         break;
       }
       if(*backAlgo != d) {
         incorrect = true;
-        fmt::print(" algo mismatch: d = {}, backAlgo = {}, parsing the output with std::from_chars does not recover the original", d, *backAlgo);
+        fmt::print(" algo mismatch: d = {}, backAlgo = {}; svRef = {}, svAlgo = {}, parsing the output with std::from_chars does not recover the original", float_to_hex(d), *backAlgo, svRef, svAlgo);
         fflush(stdout);
         break;
       }
@@ -135,7 +135,7 @@ void run_exhaustive32(bool errol) {
         break;
       }
     }
-    printf("\n");
+    fmt::print("\n");
     fmt::println("{:20} {:20}", algo.name, incorrect == 0 ? "yes" : "no");
   }
 }