Merge pull request #202 from mmore500/getuint64

Write and test uint64_t generator

Author: mercere99

source/tools/Random.h

@@ -202,6 +202,16 @@ namespace emp {
              + static_cast<uint32_t>(GetDouble() * 65536.0);
     }
 
+    /**
+     * Generate a random 64-bit block of bits.
+     *
+     * @return The pseudo random number.
+     **/
+    inline uint64_t GetUInt64() {
+      return ( static_cast<uint64_t>(GetUInt()) << 32)
+             + static_cast<uint64_t>(GetUInt());
+    }
+
     /**
      * Generate an uint64_t.
      *
@@ -371,10 +381,10 @@ namespace emp {
 
     /**
      * By default GetRandBinomial calls the full (non-approximation) version.
-     * 
+     *
      * Note that if approximations are okay, they can create a big speedup
      * for n > 1000.
-     * 
+     *
      * @see Random::GetFullRandBinomial
      * @see Random::GetApproxRandBinomial
      * @see emp::Binomial in source/tools/Binomial.h

tests/test_tools.cc

@@ -15,6 +15,8 @@
 #include <string>
 #include <deque>
 #include <algorithm>
+#include <limits>
+#include <numeric>
 #include <climits>
 #include <unordered_set>
 
@@ -1160,6 +1162,57 @@ TEST_CASE("Test random", "[tools]")
     REQUIRE(mean_value < max_threshold);
   }
 
+  // Test GetUInt()
+  emp::vector<uint32_t> uint32_draws;
+  total = 0.0;
+  for (size_t i = 0; i < num_tests; i++) {
+    const uint32_t cur_value = rng.GetUInt();
+    total += cur_value;
+    uint32_draws.push_back(cur_value);
+  }
+
+  {
+  const double expected_mean = ((double)std::numeric_limits<uint32_t>::max())/2.0;
+  const double min_threshold = (expected_mean*0.995);
+  const double max_threshold = (expected_mean*1.005);
+  double mean_value = total/(double) num_tests;
+
+  REQUIRE(mean_value > min_threshold);
+  REQUIRE(mean_value < max_threshold);
+  // ensure that all bits are set at least once and unset at least once
+  REQUIRE(std::numeric_limits<uint32_t>::max() == std::accumulate(uint32_draws.begin(),uint32_draws.end(),(uint32_t)0,
+    [](uint32_t accumulator, uint32_t val){ return accumulator | val; })
+  );
+  REQUIRE(std::numeric_limits<uint32_t>::max() == std::accumulate(uint32_draws.begin(),uint32_draws.end(),(uint32_t)0,
+    [](uint32_t accumulator, uint32_t val){ return accumulator | (~val); })
+  );
+  }
+  // Test GetUInt64
+  emp::vector<uint64_t> uint64_draws;
+  total = 0.0;
+  for (size_t i = 0; i < num_tests; i++) {
+    const uint64_t cur_value = rng.GetUInt64();
+    total += cur_value/(double)num_tests;
+    uint64_draws.push_back(cur_value);
+  }
+
+  {
+  const double expected_mean = ((double)std::numeric_limits<uint64_t>::max())/2.0;
+  const double min_threshold = (expected_mean*0.995);
+  const double max_threshold = (expected_mean*1.005);
+  double mean_value = total; // values were divided by num_tests when added
+
+  REQUIRE(mean_value > min_threshold);
+  REQUIRE(mean_value < max_threshold);
+  // ensure that all bits are set at least once and unset at least once
+  REQUIRE(std::numeric_limits<uint64_t>::max() == std::accumulate(uint64_draws.begin(),uint64_draws.end(),(uint64_t)0,
+    [](uint64_t accumulator, uint64_t val){ return accumulator | val; })
+  );
+  REQUIRE(std::numeric_limits<uint64_t>::max() == std::accumulate(uint64_draws.begin(),uint64_draws.end(),(uint64_t)0,
+    [](uint64_t accumulator, uint64_t val){ return accumulator | (~val); })
+  );
+  }
+
   // Test P
   double flip_prob = 0.56789;
   int hit_count = 0;