pcg_random.hpp: simplified implementation of operator>>, operator<< and operator==. Moved generate to pcg_core.hpp in an attempt to fix compiler errors.

Author: brt-v

include/pcg/pcg_core.hpp

@@ -85,6 +85,8 @@ namespace pcg_extras {
  #define PCG_EMULATED_128BIT_MATH 1
 #endif
 
+#include <type_traits>
+#include <iterator>
 
 namespace pcg_extras {
 
@@ -227,4 +229,167 @@ namespace pcg_extras {
 
  #endif // PCG_USE_INLINE_ASM
 
+
+
+/*
+ * The C++ SeedSeq concept (modelled by seed_seq) can fill an array of
+ * 32-bit integers with seed data, but sometimes we want to produce
+ * larger or smaller integers.
+ *
+ * The following code handles this annoyance.
+ *
+ * uneven_copy will copy an array of 32-bit ints to an array of larger or
+ * smaller ints (actually, the code is general it only needing forward
+ * iterators).  The copy is identical to the one that would be performed if
+ * we just did memcpy on a standard little-endian machine, but works
+ * regardless of the endian of the machine (or the weirdness of the ints
+ * involved).
+ *
+ * generate_to initializes an array of integers using a SeedSeq
+ * object.  It is given the size as a static constant at compile time and
+ * tries to avoid memory allocation.  If we're filling in 32-bit constants
+ * we just do it directly.  If we need a separate buffer and it's small,
+ * we allocate it on the stack.  Otherwise, we fall back to heap allocation.
+ * Ugh.
+ *
+ * generate_one produces a single value of some integral type using a
+ * SeedSeq object.
+ */
+
+ /* uneven_copy helper, case where destination ints are less than 32 bit. */
+
+template<class SrcIter, class DestIter>
+SrcIter uneven_copy_impl(
+    SrcIter src_first, DestIter dest_first, DestIter dest_last,
+    std::true_type)
+{
+    using src_t  = typename std::iterator_traits<SrcIter>::value_type;
+    using dest_t = typename std::iterator_traits<DestIter>::value_type;
+
+    constexpr bitcount_t SRC_SIZE  = sizeof(src_t);
+    constexpr bitcount_t DEST_SIZE = sizeof(dest_t);
+    constexpr bitcount_t DEST_BITS = DEST_SIZE * 8;
+    constexpr bitcount_t SCALE     = SRC_SIZE / DEST_SIZE;
+
+    size_t count = 0;
+    src_t value = 0;
+
+    while (dest_first != dest_last) {
+        if ((count++ % SCALE) == 0)
+            value = *src_first++;       // Get more bits
+        else
+            value >>= DEST_BITS;        // Move down bits
+
+        *dest_first++ = dest_t(value);  // Truncates, ignores high bits.
+    }
+    return src_first;
+}
+
+ /* uneven_copy helper, case where destination ints are more than 32 bit. */
+
+template<class SrcIter, class DestIter>
+SrcIter uneven_copy_impl(
+    SrcIter src_first, DestIter dest_first, DestIter dest_last,
+    std::false_type)
+{
+    using src_t  = typename std::iterator_traits<SrcIter>::value_type;
+    using dest_t = typename std::iterator_traits<DestIter>::value_type;
+
+    constexpr auto SRC_SIZE  = sizeof(src_t);
+    constexpr auto SRC_BITS  = SRC_SIZE * 8;
+    constexpr auto DEST_SIZE = sizeof(dest_t);
+    constexpr auto SCALE     = (DEST_SIZE+SRC_SIZE-1) / SRC_SIZE;
+
+    while (dest_first != dest_last) {
+        dest_t value(0UL);
+        unsigned int shift = 0;
+
+        for (size_t i = 0; i < SCALE; ++i) {
+            value |= dest_t(*src_first++) << shift;
+            shift += SRC_BITS;
+        }
+
+        *dest_first++ = value;
+    }
+    return src_first;
+}
+
+/* uneven_copy, call the right code for larger vs. smaller */
+
+template<class SrcIter, class DestIter>
+inline SrcIter uneven_copy(SrcIter src_first,
+                           DestIter dest_first, DestIter dest_last)
+{
+    using src_t  = typename std::iterator_traits<SrcIter>::value_type;
+    using dest_t = typename std::iterator_traits<DestIter>::value_type;
+
+    constexpr bool DEST_IS_SMALLER = sizeof(dest_t) < sizeof(src_t);
+
+    return uneven_copy_impl(src_first, dest_first, dest_last,
+                            std::integral_constant<bool, DEST_IS_SMALLER>{});
+}
+
+/* generate_to, fill in a fixed-size array of integral type using a SeedSeq
+ * (actually works for any random-access iterator)
+ */
+
+template <size_t size, typename SeedSeq, typename DestIter>
+inline void generate_to_impl(SeedSeq&& generator, DestIter dest,
+                             std::true_type)
+{
+    generator.generate(dest, dest+size);
+}
+
+template <size_t size, typename SeedSeq, typename DestIter>
+void generate_to_impl(SeedSeq&& generator, DestIter dest,
+                      std::false_type)
+{
+    using dest_t = typename std::iterator_traits<DestIter>::value_type;
+    constexpr auto DEST_SIZE = sizeof(dest_t);
+    constexpr auto GEN_SIZE  = sizeof(uint32_t);
+
+    constexpr bool GEN_IS_SMALLER = GEN_SIZE < DEST_SIZE;
+    constexpr size_t FROM_ELEMS =
+        GEN_IS_SMALLER
+            ? size * ((DEST_SIZE+GEN_SIZE-1) / GEN_SIZE)
+            : (size + (GEN_SIZE / DEST_SIZE) - 1)
+                / ((GEN_SIZE / DEST_SIZE) + GEN_IS_SMALLER);
+                        //  this odd code ^^^^^^^^^^^^^^^^^ is work-around for
+                        //  a bug: http://llvm.org/bugs/show_bug.cgi?id=21287
+
+    if constexpr (FROM_ELEMS <= 1024) {
+        uint32_t buffer[FROM_ELEMS];
+        generator.generate(buffer, buffer+FROM_ELEMS);
+        uneven_copy(buffer, dest, dest+size);
+    } else {
+        uint32_t* buffer = static_cast<uint32_t*>(malloc(GEN_SIZE * FROM_ELEMS));
+        generator.generate(buffer, buffer+FROM_ELEMS);
+        uneven_copy(buffer, dest, dest+size);
+        free(static_cast<void*>(buffer));
+    }
+}
+
+template <size_t size, typename SeedSeq, typename DestIter>
+inline void generate_to(SeedSeq&& generator, DestIter dest)
+{
+    using dest_t = typename std::iterator_traits<DestIter>::value_type;
+    constexpr bool IS_32BIT = sizeof(dest_t) == sizeof(uint32_t);
+
+    generate_to_impl<size>(std::forward<SeedSeq>(generator), dest,
+                           std::integral_constant<bool, IS_32BIT>{});
+}
+
+/* generate_one, produce a value of integral type using a SeedSeq
+ * (optionally, we can have it produce more than one and pick which one
+ * we want)
+ */
+
+template <typename UInt, size_t i = 0UL, size_t N = i + 1UL, typename SeedSeq>
+inline UInt generate_one(SeedSeq&& generator)
+{
+    UInt result[N];
+    generate_to<N>(std::forward<SeedSeq>(generator), result);
+    return result[i];
+}
+
 }

include/pcg/pcg_extras.hpp

@@ -184,166 +184,6 @@ inline std::istream& operator>>(std::istream& in, uint8_t& value)
     return pcg_extras::operator>> <char>(in, value);
 }
 
-/*
- * The C++ SeedSeq concept (modelled by seed_seq) can fill an array of
- * 32-bit integers with seed data, but sometimes we want to produce
- * larger or smaller integers.
- *
- * The following code handles this annoyance.
- *
- * uneven_copy will copy an array of 32-bit ints to an array of larger or
- * smaller ints (actually, the code is general it only needing forward
- * iterators).  The copy is identical to the one that would be performed if
- * we just did memcpy on a standard little-endian machine, but works
- * regardless of the endian of the machine (or the weirdness of the ints
- * involved).
- *
- * generate_to initializes an array of integers using a SeedSeq
- * object.  It is given the size as a static constant at compile time and
- * tries to avoid memory allocation.  If we're filling in 32-bit constants
- * we just do it directly.  If we need a separate buffer and it's small,
- * we allocate it on the stack.  Otherwise, we fall back to heap allocation.
- * Ugh.
- *
- * generate_one produces a single value of some integral type using a
- * SeedSeq object.
- */
-
- /* uneven_copy helper, case where destination ints are less than 32 bit. */
-
-template<class SrcIter, class DestIter>
-SrcIter uneven_copy_impl(
-    SrcIter src_first, DestIter dest_first, DestIter dest_last,
-    std::true_type)
-{
-    using src_t  = typename std::iterator_traits<SrcIter>::value_type;
-    using dest_t = typename std::iterator_traits<DestIter>::value_type;
-
-    constexpr bitcount_t SRC_SIZE  = sizeof(src_t);
-    constexpr bitcount_t DEST_SIZE = sizeof(dest_t);
-    constexpr bitcount_t DEST_BITS = DEST_SIZE * 8;
-    constexpr bitcount_t SCALE     = SRC_SIZE / DEST_SIZE;
-
-    size_t count = 0;
-    src_t value = 0;
-
-    while (dest_first != dest_last) {
-        if ((count++ % SCALE) == 0)
-            value = *src_first++;       // Get more bits
-        else
-            value >>= DEST_BITS;        // Move down bits
-
-        *dest_first++ = dest_t(value);  // Truncates, ignores high bits.
-    }
-    return src_first;
-}
-
- /* uneven_copy helper, case where destination ints are more than 32 bit. */
-
-template<class SrcIter, class DestIter>
-SrcIter uneven_copy_impl(
-    SrcIter src_first, DestIter dest_first, DestIter dest_last,
-    std::false_type)
-{
-    using src_t  = typename std::iterator_traits<SrcIter>::value_type;
-    using dest_t = typename std::iterator_traits<DestIter>::value_type;
-
-    constexpr auto SRC_SIZE  = sizeof(src_t);
-    constexpr auto SRC_BITS  = SRC_SIZE * 8;
-    constexpr auto DEST_SIZE = sizeof(dest_t);
-    constexpr auto SCALE     = (DEST_SIZE+SRC_SIZE-1) / SRC_SIZE;
-
-    while (dest_first != dest_last) {
-        dest_t value(0UL);
-        unsigned int shift = 0;
-
-        for (size_t i = 0; i < SCALE; ++i) {
-            value |= dest_t(*src_first++) << shift;
-            shift += SRC_BITS;
-        }
-
-        *dest_first++ = value;
-    }
-    return src_first;
-}
-
-/* uneven_copy, call the right code for larger vs. smaller */
-
-template<class SrcIter, class DestIter>
-inline SrcIter uneven_copy(SrcIter src_first,
-                           DestIter dest_first, DestIter dest_last)
-{
-    using src_t  = typename std::iterator_traits<SrcIter>::value_type;
-    using dest_t = typename std::iterator_traits<DestIter>::value_type;
-
-    constexpr bool DEST_IS_SMALLER = sizeof(dest_t) < sizeof(src_t);
-
-    return uneven_copy_impl(src_first, dest_first, dest_last,
-                            std::integral_constant<bool, DEST_IS_SMALLER>{});
-}
-
-/* generate_to, fill in a fixed-size array of integral type using a SeedSeq
- * (actually works for any random-access iterator)
- */
-
-template <size_t size, typename SeedSeq, typename DestIter>
-inline void generate_to_impl(SeedSeq&& generator, DestIter dest,
-                             std::true_type)
-{
-    generator.generate(dest, dest+size);
-}
-
-template <size_t size, typename SeedSeq, typename DestIter>
-void generate_to_impl(SeedSeq&& generator, DestIter dest,
-                      std::false_type)
-{
-    using dest_t = typename std::iterator_traits<DestIter>::value_type;
-    constexpr auto DEST_SIZE = sizeof(dest_t);
-    constexpr auto GEN_SIZE  = sizeof(uint32_t);
-
-    constexpr bool GEN_IS_SMALLER = GEN_SIZE < DEST_SIZE;
-    constexpr size_t FROM_ELEMS =
-        GEN_IS_SMALLER
-            ? size * ((DEST_SIZE+GEN_SIZE-1) / GEN_SIZE)
-            : (size + (GEN_SIZE / DEST_SIZE) - 1)
-                / ((GEN_SIZE / DEST_SIZE) + GEN_IS_SMALLER);
-                        //  this odd code ^^^^^^^^^^^^^^^^^ is work-around for
-                        //  a bug: http://llvm.org/bugs/show_bug.cgi?id=21287
-
-    if constexpr (FROM_ELEMS <= 1024) {
-        uint32_t buffer[FROM_ELEMS];
-        generator.generate(buffer, buffer+FROM_ELEMS);
-        uneven_copy(buffer, dest, dest+size);
-    } else {
-        uint32_t* buffer = static_cast<uint32_t*>(malloc(GEN_SIZE * FROM_ELEMS));
-        generator.generate(buffer, buffer+FROM_ELEMS);
-        uneven_copy(buffer, dest, dest+size);
-        free(static_cast<void*>(buffer));
-    }
-}
-
-template <size_t size, typename SeedSeq, typename DestIter>
-inline void generate_to(SeedSeq&& generator, DestIter dest)
-{
-    using dest_t = typename std::iterator_traits<DestIter>::value_type;
-    constexpr bool IS_32BIT = sizeof(dest_t) == sizeof(uint32_t);
-
-    generate_to_impl<size>(std::forward<SeedSeq>(generator), dest,
-                           std::integral_constant<bool, IS_32BIT>{});
-}
-
-/* generate_one, produce a value of integral type using a SeedSeq
- * (optionally, we can have it produce more than one and pick which one
- * we want)
- */
-
-template <typename UInt, size_t i = 0UL, size_t N = i+1UL, typename SeedSeq>
-inline UInt generate_one(SeedSeq&& generator)
-{
-    UInt result[N];
-    generate_to<N>(std::forward<SeedSeq>(generator), result);
-    return result[i];
-}
 
 template <typename RngType>
 auto bounded_rand(RngType& rng, typename RngType::result_type upper_bound)