More fixes

Author: lemire

benchmarks/CMakeLists.txt

@@ -16,7 +16,24 @@ int main(void) {
 }
 " from_chars_ok)
 target_compile_definitions(benchmark PUBLIC FROM_CHARS_SUPPORTED=$<IF:$<BOOL:${from_chars_ok}>,1,0>)
+check_source_compiles(CXX "
+#include <charconv>
+int main(void) {
+    float valuef = 0;
+    double valued = 0;
+    const char* ptr;
+    std::to_chars_result result1 = std::to_chars(ptr, ptr, valuef);
+    std::to_chars_result result2 = std::to_chars(ptr, ptr, valued);
+    return 0;
+}
+" to_chars)
+target_compile_definitions(benchmark PUBLIC TO_CHARS_SUPPORTED=$<IF:$<BOOL:${to_chars}>,1,0>)
 
+CPMAddPackage(
+  NAME fast_float
+  GITHUB_REPOSITORY "fastfloat/fast_float"
+  GIT_TAG v8.0.2)
+target_link_libraries(benchmark PUBLIC fast_float)
 if (NOT WIN32)
     target_link_libraries(benchmark PUBLIC netlib)
     target_compile_definitions(benchmark PUBLIC NETLIB_SUPPORTED=1)
@@ -25,7 +42,7 @@ else()
 endif()
 
 if (NOT CYGWIN)
-    target_link_libraries(benchmark PUBLIC absl::strings absl::str_format)
+    target_link_libraries(benchmark PUBLIC absl::str_format)
     target_compile_definitions(benchmark PUBLIC ABSEIL_SUPPORTED=1)
 else()
     target_compile_definitions(benchmark PUBLIC ABSEIL_SUPPORTED=0)

benchmarks/algorithms.h

@@ -9,7 +9,7 @@
 #include "errol.h"
 #endif
 
-#if FROM_CHARS_SUPPORTED
+#if TO_CHARS_SUPPORTED
 #include <charconv>
 #endif
 
@@ -229,7 +229,7 @@ int abseil(T d, std::span<char>& buffer) {
 
 template<arithmetic_float T>
 int std_to_chars(T d, std::span<char>& buffer) {
-#if FROM_CHARS_SUPPORTED
+#if TO_CHARS_SUPPORTED
   const auto [p, ec]
       = std::to_chars(buffer.data(), buffer.data() + buffer.size(), d);
   if (ec != std::errc()) {

benchmarks/benchmark.cpp

@@ -21,11 +21,14 @@
 #include <iostream>
 #include <string>
 #include <variant>
+#include <fast_float/fast_float.h>
+#if FROM_CHARS_SUPPORTED || TO_CHARS_SUPPORTED
+#include <charconv> // technically included by "algorithms.h"
+#endif
 
 using Benchmarks::arithmetic_float;
 using Benchmarks::BenchArgs;
 
-#if FROM_CHARS_SUPPORTED
 template <arithmetic_float T>
 void evaluateProperties(const std::vector<T> &lines,
                         const std::array<BenchArgs<T>, Benchmarks::COUNT> &args) {
@@ -46,15 +49,17 @@ void evaluateProperties(const std::vector<T> &lines,
       const int vRef = Benchmarks::std_to_chars(d, bufRef);
       bufRef[vRef] = '\0';
       T dRef;
-      auto [ptr, ec] = std::from_chars(bufRef.data(), bufRef.data() + vRef, dRef);
+      // We prefer fast_float::from_chars over std::from_chars because it is more
+      // likely to be available.
+      auto [ptr, ec] = fast_float::from_chars(bufRef.data(), bufRef.data() + vRef, dRef);
       assert(ptr == bufRef.data() + vRef);
       assert(ec == std::errc());
       assert(d == dRef);
       // Tested algorithm output
       const int vAlgo = algo.func(d, bufAlgo);
       bufAlgo[vAlgo] = '\0';
       T dAlgo;
-      auto [ptrAlgo, ecAlgo] = std::from_chars(bufAlgo.data(), bufAlgo.data() + vAlgo, dAlgo);
+      auto [ptrAlgo, ecAlgo] = fast_float::from_chars(bufAlgo.data(), bufAlgo.data() + vAlgo, dAlgo);
       assert(ptrAlgo == bufAlgo.data() + vAlgo);
       assert(ecAlgo == std::errc());
       if ((incorrect += (d != dAlgo)) == 1)
@@ -64,7 +69,6 @@ void evaluateProperties(const std::vector<T> &lines,
     fmt::println("{:20} {:20}", algo.name, incorrect == 0 ? "yes" : "no");
   }
 }
-#endif // FROM_CHARS_SUPPORTED
 
 template <arithmetic_float T>
 void process(const std::vector<T> &lines,
@@ -133,23 +137,22 @@ cxxopts::Options
 
 int main(int argc, char **argv) {
   try {
-    options.add_options()("f,file", "File name.",
-                          cxxopts::value<std::string>()->default_value(""))(
-        "v,volume", "Volume (number of floats generated).",
-        cxxopts::value<size_t>()->default_value("100000"))(
-        "m,model", "Random Model.",
-        cxxopts::value<std::string>()->default_value("uniform"))(
-        "s,single", "Use single precision instead of double.",
+    options.add_options()
+        ("f,file", "File name.",
+        cxxopts::value<std::string>()->default_value(""))
+        ("v,volume", "Volume (number of floats generated).",
+        cxxopts::value<size_t>()->default_value("100000"))
+        ("m,model", "Random Model.",
+        cxxopts::value<std::string>()->default_value("uniform"))
+        ("s,single", "Use single precision instead of double.",
         cxxopts::value<bool>()->default_value("false"))
-#if FROM_CHARS_SUPPORTED
         ("t,test", "Test the algorithms and find their properties.",
         cxxopts::value<bool>()->default_value("false"))
-#endif // FROM_CHARS_SUPPORTED
         ("d,dragon", "Enable dragon4 (current impl. triggers some asserts).",
-        cxxopts::value<bool>()->default_value("false"))(
-        "e,errol", "Enable errol3 (current impl. returns invalid values, e.g., for 0).",
-        cxxopts::value<bool>()->default_value("false"))(
-        "h,help", "Print usage.");
+        cxxopts::value<bool>()->default_value("false"))
+        ("e,errol", "Enable errol3 (current impl. returns invalid values, e.g., for 0).",
+        cxxopts::value<bool>()->default_value("false"))
+        ("h,help", "Print usage.");
     const auto result = options.parse(argc, argv);
 
     if (result["help"].as<bool>()) {
@@ -198,7 +201,7 @@ int main(int argc, char **argv) {
       args[Benchmarks::TEJU_JAGUA]        = { "teju_jagua"        , Benchmarks::teju_jagua<T>        , true };
       args[Benchmarks::DOUBLE_CONVERSION] = { "double_conversion" , Benchmarks::double_conversion<T> , true };
       args[Benchmarks::ABSEIL]            = { "abseil"            , Benchmarks::abseil<T>            , ABSEIL_SUPPORTED };
-      args[Benchmarks::STD_TO_CHARS]      = { "std::to_chars"     , Benchmarks::std_to_chars<T>      , FROM_CHARS_SUPPORTED };
+      args[Benchmarks::STD_TO_CHARS]      = { "std::to_chars"     , Benchmarks::std_to_chars<T>      , TO_CHARS_SUPPORTED };
       return args;
     };
 
@@ -214,11 +217,9 @@ int main(int argc, char **argv) {
       using T1 = typename std::decay_t<decltype(lines)>::value_type;
       using T2 = typename std::decay_t<decltype(args)>::value_type::Type;
       if constexpr (std::is_same_v<T1, T2>) {
-#if FROM_CHARS_SUPPORTED
         if (test)
           evaluateProperties(lines, args);
         else
-#endif // FROM_CHARS_SUPPORTED
           process(lines, args);
       }
     }, numbers, algorithms);