[gen.hpp] WNDX_ALGO_FIXED_SEED, explicit std::move, cleanup,

WNDX_MSC - non cryptographic randomness via chrono time_since_epoch().

explicit std::move containers - to not rely on NRVO (named return value optimization).

Author: WANDEX

include/wndx/algo/util/gen.hpp

@@ -16,6 +16,15 @@
 #endif//defined ...
 #endif//WNDX_MSC
 
+#ifndef WNDX_ALGO_FIXED_SEED
+#define WNDX_ALGO_FIXED_SEED 0
+#endif//WNDX_ALGO_FIXED_SEED
+
+#if WNDX_MSC && !WNDX_ALGO_FIXED_SEED
+#include <chrono>
+#include <cstdint>              // std::uint64_t
+#endif//WNDX_MSC
+
 namespace wndx::algo {
 namespace gen {
 
@@ -25,10 +34,17 @@ namespace gen {
  */
 inline std::mt19937& g_rng()
 {
-#if WNDX_MSC
+#if WNDX_MSC || WNDX_ALGO_FIXED_SEED
     // deterministic seeding! std::random_device => drmemory "WARNING: writing to readonly memory".
     // because of the SH*TTY WIN random_* implementation: BCryptGenRandom, CryptGenRandom, etc.
-    constexpr int seed{ 123456 };
+  #if WNDX_ALGO_FIXED_SEED
+    constexpr std::size_t seed{ 9876543210 }; // fixed seed (value chosen arbitrarily)
+  #else
+    static const auto now{ std::chrono::steady_clock::now().time_since_epoch() };
+    static const std::uint64_t seed{ static_cast<std::uint64_t>(
+        std::chrono::duration_cast<std::chrono::seconds>(now).count()
+    )};
+  #endif//WNDX_ALGO_FIXED_SEED
     static std::mt19937 s_rng(seed);
 #else
     static std::random_device s_rd;
@@ -37,33 +53,6 @@ inline std::mt19937& g_rng()
     return s_rng;
 }
 
-#if 0
-/**
- * @brief simple random number generator.
- *
- * @param  fr - range from the number (lower bound of the distribution).
- * @param  to - range to the number (upper bound of the distribution).
- * @return random number in range of distribution.
- *
- * NOTE: construcs a new std::random_device and engine on every call
- * => expensive and can degrade randomness on some platforms.
- */
-template<typename T>
-inline T srng(const T fr, const T to)
-{
-#if WNDX_MSC
-    // deterministic seeding! std::random_device => drmemory error "UNADDRESSABLE ACCESS: reading".
-    // because of the SH*TTY WIN random_* implementation: BCryptGenRandom, CryptGenRandom, etc.
-    constexpr int seed{ 123456 };
-    std::default_random_engine rng(seed);
-#else
-    std::random_device rd;
-    std::default_random_engine rng(rd());
-#endif
-    std::uniform_real_distribution<double> dist(static_cast<double>(fr), static_cast<double>(to));
-    return static_cast<T>(dist(rng));
-}
-#else
 /**
  * @brief simple random number generator.
  *
@@ -82,7 +71,6 @@ inline T srng(const T fr, const T to)
         return dist(g_rng());
     }
 }
-#endif
 
 /**
  * @brief @return generate random unordered_set containing n unique elements.
@@ -108,11 +96,11 @@ inline std::unordered_set<T> random_uset(const std::size_t n, const T fr, const
         } while(!((uset.insert(rn)).second));
         // ^ loop till successful insert of unique value
     }
-    return uset;
+    return std::move(uset);
 }
 
 /**
- * @brief generate random C array.
+ * @brief random fill C-style array.
  *
  * @param  fr - range from the number (lower bound of the distribution).
  * @param  to - range to the number (upper bound of the distribution).
@@ -121,8 +109,9 @@ inline std::unordered_set<T> random_uset(const std::size_t n, const T fr, const
 template<typename T>
 inline void random(T *out, const std::size_t n, const T fr, const T to)
 {
-    for (std::size_t i = 0; i < n; i++)
+    for (std::size_t i = 0; i < n; i++) {
         out[i] = gen::srng<T>(fr, to);
+    }
 }
 
 /**
@@ -136,9 +125,10 @@ template<typename T, std::size_t n>
 inline std::array<T, n> random(const T fr, const T to)
 {
     std::array<T, n> out;
-    for (std::size_t i = 0; i < n; i++)
+    for (std::size_t i = 0; i < n; i++) {
         out.at(i) = gen::srng<T>(fr, to);
-    return out;
+    }
+    return std::move(out);
 }
 
 /**
@@ -152,48 +142,16 @@ inline std::array<T, n> random(const T fr, const T to)
 template<typename T>
 inline std::vector<T> random(const std::size_t n, const T fr, const T to, const bool unique=false)
 {
-    // if (n == 0) return {}; // XXX
     if (unique) {
         std::unordered_set<T> uset{ gen::random_uset<T>(n, fr, to) };
         return{ uset.begin(), uset.end() };
     }
-#if 1
     std::vector<T> out(n);
-#else
-    std::vector<T> out;
-    out.reserve(n); // allocate space but keep size = 0
-    // out.resize(n);  // size bocomes n
-#endif
-    // std::random_device rd;
-    // std::mt19937 rng(rd());
-#if 0
-    // drmemory UNADDRESSABLE ACCESS: reading
-    std::uniform_int_distribution<T> dist(fr, to);
-    std::generate_n(out.begin(), n, [&rng, &dist]() { return dist(rng); });
-#else
     for (std::size_t i = 0; i < n; i++) {
-    #if 1
         out.at(i) = gen::srng<T>(fr, to);
-        // out[i] = gen::srng<T>(fr, to);
-    #elif 1
-        out[i] = static_cast<T>(to); // XXX
-    #elif 1
-        std::uniform_int_distribution<T> dist(fr, to);
-        T val = dist(rng);
-        out[i] = val;
-    #elif 0
-        std::uniform_int_distribution<T> dist; // default ctor
-        dist.param(typename std::uniform_int_distribution<T>::param_type(fr, to));
-        out[i] = dist(rng);
-    #else
-        T val = gen::srng<T>(fr, to); // ensure a copy, not a reference | copy from read-only source
-        out[i] = val;
-    #endif
     }
-#endif
     return std::move(out);
-    // return out; // rely on NRVO (named return value optimization)
 }
 
 } // namespace gen
-} // namespace wndx::algo
+} // namespace wndx::algo