Remove some redundencies and fix some typos

Author: jaja360

benchmarks/algorithms.h

@@ -30,6 +30,7 @@
 #include "grisu3.h"
 #include "grisu_exact.h"
 #include "ieeeToString.h"
+#include "floatutils.h"
 #include "ryu/ryu.h"
 #include "schubfach_32.h"
 #include "schubfach_64.h"
@@ -67,10 +68,6 @@ enum Algorithm {
   COUNT // Keep last
 };
 
-template<typename T>
-concept arithmetic_float
-    = std::is_same_v<T, float> || std::is_same_v<T, double>;
-
 template<arithmetic_float T>
 struct BenchArgs {
   using Type = T;

benchmarks/benchmark.cpp

@@ -8,7 +8,6 @@
  */
 
 #include "algorithms.h"
-#include <vector>
 #define IEEE_8087
 #include "benchutil.h"
 #include "cxxopts.hpp"
@@ -22,10 +21,10 @@
 #include <iostream>
 #include <string>
 #include <variant>
+#include <vector>
 #include <fast_float/fast_float.h>
 #include <fmt/core.h>
 
-using Benchmarks::arithmetic_float;
 using Benchmarks::BenchArgs;
 
 bool is_matched(const std::string &str, const std::span<std::string> filter) {
@@ -42,8 +41,8 @@ bool is_matched(const std::string &str, const std::span<std::string> filter) {
 
 template <arithmetic_float T>
 void evaluateProperties(const std::vector<T> &lines,
-                        const std::array<BenchArgs<T>, Benchmarks::COUNT> &args, const std::span<std::string> filter = {}) {
-  constexpr auto precision = std::numeric_limits<T>::digits10;
+                        const std::array<BenchArgs<T>, Benchmarks::COUNT> &args,
+                        const std::span<std::string> filter = {}) {
   fmt::println("{:20} {:20}", "Algorithm", "Valid round-trip");
 
   for (const auto &algo : args) {

benchmarks/benchutil.h

@@ -17,7 +17,7 @@ event_aggregate bench(const function_type &&function, size_t min_repeat = 10,
     N = 1;
   }
   volatile double dontoptimize = 0.0;
-  // We warmm up first. We warmup for at least 0.4s (by default). This makes
+  // We warm up first. We warmup for at least 0.4s (by default). This makes
   // sure that the processor is in a consistent state.
   event_aggregate warm_aggregate{};
   for (size_t i = 0; i < N; i++) {
@@ -89,4 +89,5 @@ void pretty_print(const std::vector<T> &lines, const std::string &name,
     printf("\n");
   }
 }
+
 #endif //// BENCHUTIL_H

benchmarks/exhaustivefloat32.cpp

@@ -12,56 +12,9 @@
 
 #include "algorithms.h"
 #include "cxxopts.hpp"
-
-size_t count_significant_digits(std::string_view num_str) {
-  size_t count = 0;
-  size_t trailing_zeros = 0;
-  bool leading_zero = true;
-
-  for (char c : num_str) {
-    if (c == '.')
-      continue;
-    if (c == 'e' || c == 'E')
-      break; // Stop counting at exponent
-    if (std::isdigit(static_cast<unsigned char>(c))) {
-      if (c == '0') {
-        if (!leading_zero)
-          trailing_zeros++;
-        continue;
-      }
-      leading_zero = false;
-      count += trailing_zeros + 1;
-      trailing_zeros = 0;
-    }
-  }
-
-  return count;
-}
-
-std::string float_to_hex(float f) {
-  std::ostringstream oss;
-  oss << std::hexfloat << f;
-  return oss.str();
-}
-
-std::optional<float> parse_float(std::string_view sv) {
-  float result;
-  const char* begin = sv.data();
-  const char* end = sv.data() + sv.size();
-
-  auto [ptr, ec] = std::from_chars(begin, end, result);
-
-  // Check if parsing succeeded and consumed the entire string
-  if (ec == std::errc{} && ptr == end) {
-      return result;
-  }
-
-  // Return nullopt if parsing failed or didn't consume all input
-  return std::nullopt;
-}
+#include "floatutils.h"
 
 void run_exhaustive32(bool errol, const std::vector<std::string>& algo_filter = {}) {
-  constexpr auto precision = std::numeric_limits<float>::digits10;
   fmt::println("{:20} {:20}", "Algorithm", "Valid shortest serialization");
 
   std::array<Benchmarks::BenchArgs<float>, Benchmarks::COUNT> args;
@@ -110,7 +63,7 @@ void run_exhaustive32(bool errol, const std::vector<std::string>& algo_filter =
         continue;
       // Reference output, we cannot use std::to_chars here, because it produces
       // the shortest representation, which is not necessarily the same as the
-      // as the representation using the fewest significant digits.
+      // representation using the fewest significant digits.
       // So we use dragonbox, which serves as the reference implementation.
       const size_t vRef = Benchmarks::dragonbox(d, bufRef);
       const size_t vAlgo = algo.func(d, bufAlgo);
@@ -120,12 +73,12 @@ void run_exhaustive32(bool errol, const std::vector<std::string>& algo_filter =
 
       auto countRef = count_significant_digits(svRef);
       auto countAlgo = count_significant_digits(svAlgo);
-      auto backRef = parse_float(svRef);
-      auto backAlgo = parse_float(svAlgo);
+      auto backRef = parse_float<float>(svRef);
+      auto backAlgo = parse_float<float>(svAlgo);
       if(!backRef || !backAlgo) {
         incorrect = true;
-        fmt::print(" parse error: d = {}, bufRef = {}, bufAlgo = {}", float_to_hex(d),
-                   svRef, svAlgo);
+        fmt::print(" parse error: d = {}, bufRef = {}, bufAlgo = {}",
+                   float_to_hex<float>(d), svRef, svAlgo);
         fflush(stdout);
         break;
       }
@@ -134,20 +87,23 @@ void run_exhaustive32(bool errol, const std::vector<std::string>& algo_filter =
       }
       if(*backRef != d) {
         incorrect = true;
-        fmt::print(" ref mismatch: d = {}, backRef = {}; svRef = {}, svAlgo = {}", float_to_hex(d), *backRef, svRef, svAlgo);
+        fmt::print(" ref mismatch: d = {}, backRef = {}; svRef = {}, svAlgo = {}",
+                   float_to_hex<float>(d), *backRef, svRef, svAlgo);
         fflush(stdout);
         break;
       }
       if(*backAlgo != d) {
         incorrect = true;
-        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);
+        fmt::print(" algo mismatch: d = {}, backAlgo = {}; svRef = {}, svAlgo = {}, "
+                   "parsing the output with std::from_chars does not recover the original",
+                   float_to_hex<float>(d), *backAlgo, svRef, svAlgo);
         fflush(stdout);
         break;
       }
       if (countRef != countAlgo) {
         incorrect = true;
-        fmt::print(" mismatch: d = {}, bufRef = {}, bufAlgo = {}", float_to_hex(d),
-                   svRef, svAlgo);
+        fmt::print(" mismatch: d = {}, bufRef = {}, bufAlgo = {}",
+                   float_to_hex<float>(d), svRef, svAlgo);
         fflush(stdout);
         break;
       }

benchmarks/floatutils.h

@@ -0,0 +1,62 @@
+#ifndef FLOATUTILS_H
+#define FLOATUTILS_H
+
+#include <charconv>
+#include <string>
+#include <sstream>
+#include <optional>
+
+template<typename T>
+concept arithmetic_float
+    = std::is_same_v<T, float> || std::is_same_v<T, double>;
+
+size_t count_significant_digits(std::string_view num_str) {
+  size_t count = 0;
+  size_t trailing_zeros = 0;
+  bool leading_zero = true;
+
+  for (char c : num_str) {
+    if (c == '.')
+      continue;
+    if (c == 'e' || c == 'E')
+      break; // Stop counting at exponent
+    if (std::isdigit(static_cast<unsigned char>(c))) {
+      if (c == '0') {
+        if (!leading_zero)
+          trailing_zeros++;
+        continue;
+      }
+      leading_zero = false;
+      count += trailing_zeros + 1;
+      trailing_zeros = 0;
+    }
+  }
+
+  return count;
+}
+
+template <arithmetic_float T>
+std::string float_to_hex(const T f) {
+  std::ostringstream oss;
+  oss << std::hexfloat << f;
+  return oss.str();
+}
+
+template <arithmetic_float T>
+std::optional<T> parse_float(std::string_view sv) {
+  T result;
+  const char* begin = sv.data();
+  const char* end = sv.data() + sv.size();
+
+  auto [ptr, ec] = std::from_chars(begin, end, result);
+
+  // Check if parsing succeeded and consumed the entire string
+  if (ec == std::errc{} && ptr == end) {
+      return result;
+  }
+
+  // Return nullopt if parsing failed or didn't consume all input
+  return std::nullopt;
+}
+
+#endif

benchmarks/string_format.h

@@ -22,6 +22,7 @@ template <typename T> std::string accurate_to_string(T d) {
   answer.resize(written);
   return answer;
 }
+
 template <typename T> std::string integer_to_string(T d) {
   std::stringstream ss;
   ss << d;

benchmarks/thoroughfloat64.cpp

@@ -14,53 +14,7 @@
 
 #include "algorithms.h"
 #include "cxxopts.hpp"
-
-size_t count_significant_digits(std::string_view num_str) {
-  size_t count = 0;
-  size_t trailing_zeros = 0;
-  bool leading_zero = true;
-
-  for (char c : num_str) {
-    if (c == '.')
-      continue;
-    if (c == 'e' || c == 'E')
-      break; // Stop counting at exponent
-    if (std::isdigit(static_cast<unsigned char>(c))) {
-      if (c == '0') {
-        if (!leading_zero)
-          trailing_zeros++;
-        continue;
-      }
-      leading_zero = false;
-      count += trailing_zeros + 1;
-      trailing_zeros = 0;
-    }
-  }
-
-  return count;
-}
-
-std::string double_to_hex(double d) {
-  std::ostringstream oss;
-  oss << std::hexfloat << d;
-  return oss.str();
-}
-
-std::optional<double> parse_double(std::string_view sv) {
-  double result;
-  const char* begin = sv.data();
-  const char* end = sv.data() + sv.size();
-
-  auto [ptr, ec] = std::from_chars(begin, end, result);
-
-  // Check if parsing succeeded and consumed the entire string
-  if (ec == std::errc{} && ptr == end) {
-      return result;
-  }
-
-  // Return nullopt if parsing failed or didn't consume all input
-  return std::nullopt;
-}
+#include "floatutils.h"
 
 struct test_case {
   double value;
@@ -71,27 +25,24 @@ struct test_case {
 std::vector<test_case> load_doubles_from_file(const std::string& filename) {
   std::vector<test_case> numbers;
   std::ifstream file(filename);
-  std::string line;
 
   if (!file.is_open()) {
     fmt::print("Error: Could not open file {}\n", filename);
     return numbers;
   }
 
-  while (std::getline(file, line)) {
-    if (auto num = parse_double(line)) {
+  for (std::string line; std::getline(file, line);) {
+    if (auto num = parse_float<double>(line))
       numbers.emplace_back(*num,line);
-    } else {
+    else
       fmt::print("Warning: Could not parse '{}' as double, skipping\n", line);
-    }
   }
 
   file.close();
   return numbers;
 }
 
 void run_file_test(const std::string& filename, bool errol, const std::vector<std::string>& algo_filter = {}) {
-  constexpr auto precision = std::numeric_limits<double>::digits10;
   fmt::println("{:20} {:20}", "Algorithm", "Valid shortest serialization");
 
   std::array<Benchmarks::BenchArgs<double>, Benchmarks::COUNT> args;
@@ -155,13 +106,13 @@ void run_file_test(const std::string& filename, bool errol, const std::vector<st
 
       auto countRef = count_significant_digits(svRef);
       auto countAlgo = count_significant_digits(svAlgo);
-      auto backRef = parse_double(svRef);
-      auto backAlgo = parse_double(svAlgo);
+      auto backRef = parse_float<double>(svRef);
+      auto backAlgo = parse_float<double>(svAlgo);
 
       if(!backRef || !backAlgo) {
         incorrect = true;
-        fmt::print(" parse error: case: {}; d = {}, bufRef = {}, bufAlgo = {}", str_value, double_to_hex(d),
-                   svRef, svAlgo);
+        fmt::print(" parse error: case: {}; d = {}, bufRef = {}, bufAlgo = {}",
+                   str_value, float_to_hex<double>(d), svRef, svAlgo);
         fflush(stdout);
         break;
       }
@@ -170,20 +121,23 @@ void run_file_test(const std::string& filename, bool errol, const std::vector<st
       }
       if(*backRef != d) {
         incorrect = true;
-        fmt::print(" ref mismatch:case: {};  d = {}, backRef = {}; svRef = {}, svAlgo = {}", str_value, double_to_hex(d), *backRef, svRef, svAlgo);
+        fmt::print(" ref mismatch:case: {};  d = {}, backRef = {}; svRef = {}, svAlgo = {}",
+                   str_value, float_to_hex<double>(d), *backRef, svRef, svAlgo);
         fflush(stdout);
         break;
       }
       if(*backAlgo != d) {
         incorrect = true;
-        fmt::print(" algo mismatch: case: {}; d = {}, backAlgo = {}; svRef = {}, svAlgo = {}, parsing the output with std::from_chars does not recover the original", str_value, double_to_hex(d), *backAlgo, svRef, svAlgo);
+        fmt::print(" algo mismatch: case: {}; d = {}, backAlgo = {}; svRef = {}, svAlgo = {}, "
+                   "parsing the output with std::from_chars does not recover the original",
+                   str_value, float_to_hex<double>(d), *backAlgo, svRef, svAlgo);
         fflush(stdout);
         break;
       }
       if (countRef != countAlgo) {
         incorrect = true;
-        fmt::print(" mismatch: case: {}; d = {}, bufRef = {}, bufAlgo = {}", str_value, double_to_hex(d),
-                   svRef, svAlgo);
+        fmt::print(" mismatch: case: {}; d = {}, bufRef = {}, bufAlgo = {}",
+                   str_value, float_to_hex<double>(d), svRef, svAlgo);
         fflush(stdout);
         break;
       }
@@ -222,4 +176,4 @@ int main(int argc, char **argv) {
     fmt::print("error parsing options: {}\n", e.what());
     return EXIT_FAILURE;
   }
-}
+}