2 files changed, 77 insertions, 0 deletions
diff --git a/src/random.cpp b/src/random.cpp
new file mode 100644
index 00000000..82c47ff9
--- /dev/null
+++ b/src/random.cpp
@@ -0,0 +1,45 @@
+#include "random.hpp"
+#include <random>
+#include <limits>
+
+namespace floormat {
+
+static thread_local auto g = std::independent_bits_engine<decltype(std::ranlux48{}), 32, std::uint32_t>{std::ranlux48{}};
+
+struct random_engine_impl final : random_engine {
+    std::size_t operator()() override;
+    float operator()(float min, float max) override;
+};
+
+std::size_t random_engine_impl::operator()()
+{
+    if constexpr(sizeof(std::size_t) > sizeof(std::uint32_t))
+    {
+        constexpr std::size_t N = (sizeof(std::size_t) + sizeof(std::uint32_t)-1) / sizeof(std::uint32_t);
+        static_assert(N >= 2);
+        union {
+            std::size_t x;
+            std::uint32_t a[N];
+        } ret;
+#pragma omp unroll full
+        for (std::size_t i = 0; i < N; i++)
+            ret.a[i] = g();
+        return ret.x;
+    }
+    else
+        return (std::size_t)g();
+}
+
+float random_engine_impl::operator()(float min, float max)
+{
+    std::uniform_real_distribution<float> dist{min, max};
+    return dist(g);
+}
+
+static random_engine& make_random_impl() {
+    static random_engine_impl ret;
+    return ret;
+}
+random_engine& random = make_random_impl();
+
+} // namespace floormat
diff --git a/src/random.hpp b/src/random.hpp
new file mode 100644
index 00000000..3616aabf
--- /dev/null
+++ b/src/random.hpp
@@ -0,0 +1,32 @@
+#pragma once
+#include <cstddef>
+#include <concepts>
+#include <type_traits>
+
+namespace floormat {
+
+struct random_engine
+{
+    virtual inline ~random_engine();
+    virtual std::common_type_t<std::size_t, std::uintptr_t, std::ptrdiff_t> operator()() = 0;
+
+    template<std::integral T>
+    requires (sizeof(T) <= sizeof(std::size_t))
+    T operator()(T max) {
+        return static_cast<T>(operator()() % static_cast<std::size_t>(max));
+    }
+
+    template<std::integral T>
+    requires (sizeof(T) <= sizeof(std::size_t))
+    T operator()(T min, T max) {
+        return min + operator()(max-min);
+    }
+
+    virtual float operator()(float min, float max) = 0;
+};
+
+random_engine::~random_engine() = default;
+
+[[maybe_unused]] extern random_engine& random; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
+} // namespace floormat