add new numbers generator

- uniform: we can now selectively generate only in [0, 1] or among all possible floats
- new centered/non-centered generators

Author: jaja360

benchmarks/random_generators.h

@@ -2,6 +2,7 @@
 #define RANDOM_GENERATORS_H
 
 #include <array>
+#include <bit>
 #include <memory>
 #include <random>
 #include <iostream>
@@ -22,13 +23,42 @@ struct uniform_generator : float_number_generator<T> {
   explicit uniform_generator(T a = 0.0, T b = 1.0)
       : rd(), gen(rd()), dis(a, b) {}
   std::string describe() override {
-    return std::string("generate random numbers uniformly in the interval [") +
+    return "generate random numbers uniformly in the interval [" +
            std::to_string((dis.min)()) + std::string(",") +
            std::to_string((dis.max)()) + std::string("]");
   }
   T new_float() override { return dis(gen); }
 };
 
+enum centering { centered, non_centered };
+template <std::floating_point T, centering C>
+struct centered_generator : float_number_generator<T> {
+  constexpr static int MAN_BITS = sizeof(T) == 4 ? 23 : 52;
+  constexpr static int EXP_BITS = sizeof(T) == 4 ? 8 : 11;
+  std::random_device rd;
+  std::mt19937_64 gen;
+  std::uniform_int_distribution<uint32_t> dist_sign;
+  std::uniform_int_distribution<uint32_t> dist_exp; // exclut 0=subnormal et max=inf/NaN
+  std::uniform_int_distribution<uint64_t> dist_man; // mantisse, sauf le LSB
+  explicit centered_generator()
+      : rd(), gen(rd()), dist_sign(0, 1),
+        dist_exp(1u << (EXP_BITS - 1), (1u << EXP_BITS) - 2),
+        dist_man(1ull, (1ull << MAN_BITS) - 1) {}
+  std::string describe() override {
+    return "generate random "
+      + (C == centered ? std::string("centered") : std::string("non-centered"))
+      + " numbers uniformly among all normal floating-point numbers";
+  }
+  T new_float() override {
+    using type_t = typename std::conditional_t< sizeof(T) == 4, uint32_t, uint64_t>;
+    const type_t sign = dist_sign(gen);
+    const type_t exp  = dist_exp(gen);
+    const type_t man  = C == centered ? dist_man(gen) : 0u;
+    const type_t bits = (sign << (EXP_BITS + MAN_BITS)) | (exp << MAN_BITS) | man;
+    return std::bit_cast<T>(bits);
+  }
+};
+
 template <typename T>
 struct integer_uniform_generator : float_number_generator<T> {
   std::random_device rd;
@@ -37,8 +67,7 @@ struct integer_uniform_generator : float_number_generator<T> {
   explicit integer_uniform_generator(long a = LONG_MIN, long b = LONG_MAX)
       : rd(), gen(rd()), dis(a, b) {}
   std::string describe() override {
-    return std::string(
-               "generate random integers numbers uniformly in the interval [") +
+    return "generate random integers numbers uniformly in the interval [" +
            std::to_string((dis.min)()) + std::string(",") +
            std::to_string((dis.max)()) + std::string("]");
   }
@@ -47,9 +76,8 @@ struct integer_uniform_generator : float_number_generator<T> {
 
 template <typename T>
 struct simple_uniform : float_number_generator<T> {
-  using gen_type = std::conditional_t<sizeof(T) == 4, std::mt19937, std::mt19937_64>;
   std::random_device rd;
-  gen_type gen;
+  std::mt19937_64 gen;
   explicit simple_uniform() : rd(), gen(rd()) {}
   std::string describe() override { return "rand() / 0xFFFFFFFF "; }
   T new_float() override {
@@ -60,7 +88,6 @@ struct simple_uniform : float_number_generator<T> {
 
 template <typename T>
 struct simple_int : float_number_generator<T> {
-  using gen_type = std::conditional_t<sizeof(T) == 4, std::mt19937, std::mt19937_64>;
   std::random_device rd;
   std::mt19937_64 gen;
   std::string describe() override { return "rand()"; }
@@ -70,9 +97,8 @@ struct simple_int : float_number_generator<T> {
 
 template <typename T>
 struct one_over_rand : float_number_generator<T> {
-  using gen_type = std::conditional_t<sizeof(T) == 4, std::mt19937, std::mt19937_64>;
   std::random_device rd;
-  gen_type gen;
+  std::mt19937_64 gen;
   explicit one_over_rand() : rd(), gen(rd()) {}
   std::string describe() override { return "1 / rand()"; }
   T new_float() override {
@@ -85,9 +111,10 @@ struct one_over_rand : float_number_generator<T> {
   }
 };
 
-constexpr std::array<const char*, 5> model_names = {
-  "uniform",      "integer_uniform",
-  "simple_uniform", "simple_int",
+constexpr std::array<const char*, 8> model_names = {
+  "uniform_01"     , "uniform_all"  , "integer_uniform" ,
+  "centered"       , "non_centered" ,
+  "simple_uniform" , "simple_int"   ,
   "one_over_rand"
 };
 
@@ -101,23 +128,29 @@ get_generator_by_name(std::string name) {
   std::cout << std::endl;
 
   // This is naive, but also not very important.
-  if (name == "uniform") {
+  if (name == "uniform_01")
     return std::unique_ptr<float_number_generator<T>>(new uniform_generator<T>());
+  if (name == "uniform_all") {
+    return std::unique_ptr<float_number_generator<T>>(
+        new uniform_generator<T>(std::numeric_limits<T>::lowest(),
+                                 std::numeric_limits<T>::max())
+    );
   }
-  if (name == "integer_uniform") {
+  if (name == "centered")
+    return std::unique_ptr<float_number_generator<T>>(new centered_generator<T, centered>());
+  if (name == "non_centered")
+    return std::unique_ptr<float_number_generator<T>>(new centered_generator<T, non_centered>());
+  if (name == "integer_uniform")
     return std::unique_ptr<float_number_generator<T>>(new integer_uniform_generator<T>());
-  }
-  if (name == "simple_uniform") {
+  if (name == "simple_uniform")
     return std::unique_ptr<float_number_generator<T>>(new simple_uniform<T>());
-  }
-  if (name == "simple_int") {
+  if (name == "simple_int")
     return std::unique_ptr<float_number_generator<T>>(new simple_int<T>());
-  }
-  if (name == "one_over_rand") {
+  if (name == "one_over_rand")
     return std::unique_ptr<float_number_generator<T>>(new one_over_rand<T>());
-  }
+
   std::cerr << " I do not recognize " << name << std::endl;
-  std::cerr << " Warning: falling back on uniform generator. " << std::endl;
+  std::cerr << " Warning: falling back on uniform_01 generator. " << std::endl;
   return std::unique_ptr<float_number_generator<T>>(new uniform_generator<T>());
 }