diff options
Diffstat (limited to 'absl/random/internal')
| -rw-r--r-- | absl/random/internal/fast_uniform_bits.h | 52 | ||||
| -rw-r--r-- | absl/random/internal/fast_uniform_bits_test.cc | 155 |
2 files changed, 17 insertions, 190 deletions
diff --git a/absl/random/internal/fast_uniform_bits.h b/absl/random/internal/fast_uniform_bits.h index 23eabbc8444c..184a2708b2af 100644 --- a/absl/random/internal/fast_uniform_bits.h +++ b/absl/random/internal/fast_uniform_bits.h @@ -38,14 +38,12 @@ constexpr typename URBG::result_type constexpr_range() { // from a type which conforms to the [rand.req.urbg] concept. // Parameterized by: // `UIntType`: the result (output) type -// `Width`: binary output width // // The std::independent_bits_engine [rand.adapt.ibits] adaptor can be // instantiated from an existing generator through a copy or a move. It does // not, however, facilitate the production of pseudorandom bits from an un-owned // generator that will outlive the std::independent_bits_engine instance. -template <typename UIntType = uint64_t, - size_t Width = std::numeric_limits<UIntType>::digits> +template <typename UIntType = uint64_t> class FastUniformBits { static_assert(std::is_unsigned<UIntType>::value, "Class-template FastUniformBits<> must be parameterized using " @@ -53,29 +51,14 @@ class FastUniformBits { // `kWidth` is the width, in binary digits, of the output. By default it is // the number of binary digits in the `result_type`. - static constexpr size_t kWidth = Width; - static_assert(kWidth > 0, - "Class-template FastUniformBits<> Width argument must be > 0"); - - static_assert(kWidth <= std::numeric_limits<UIntType>::digits, - "Class-template FastUniformBits<> Width argument must be <= " - "width of UIntType."); - - static constexpr bool kIsMaxWidth = - (kWidth >= std::numeric_limits<UIntType>::digits); - - // Computes a mask of `n` bits for the `UIntType`. - static constexpr UIntType constexpr_mask(size_t n) { - return (UIntType(1) << n) - 1; - } + static constexpr size_t kWidth = std::numeric_limits<UIntType>::digits; public: using result_type = UIntType; static constexpr result_type(min)() { return 0; } static constexpr result_type(max)() { - return kIsMaxWidth ? (std::numeric_limits<result_type>::max)() - : constexpr_mask(kWidth); + return (std::numeric_limits<result_type>::max)(); } template <typename URBG> @@ -166,7 +149,6 @@ class FastUniformBitsURBGConstants { // URBG::result_type values are combined into an output_value. // Parameterized by the FastUniformBits parameters: // `UIntType`: output type. -// `Width`: binary output width, // `URNG`: The underlying UniformRandomNumberGenerator. // // The looping constants describe the sets of loop counters and mask values @@ -177,10 +159,10 @@ class FastUniformBitsURBGConstants { // bit per variate. // // See [rand.adapt.ibits] for more details on the use of these constants. -template <typename UIntType, size_t Width, typename URBG> +template <typename UIntType, typename URBG> class FastUniformBitsLoopingConstants { private: - static constexpr size_t kWidth = Width; + static constexpr size_t kWidth = std::numeric_limits<UIntType>::digits; using urbg_result_type = typename URBG::result_type; using uint_result_type = UIntType; @@ -229,19 +211,19 @@ class FastUniformBitsLoopingConstants { "Class-template FastUniformBitsLoopingConstants::kW0 too small."); }; -template <typename UIntType, size_t Width> +template <typename UIntType> template <typename URBG> -typename FastUniformBits<UIntType, Width>::result_type -FastUniformBits<UIntType, Width>::operator()( +typename FastUniformBits<UIntType>::result_type +FastUniformBits<UIntType>::operator()( URBG& g) { // NOLINT(runtime/references) using constants = FastUniformBitsURBGConstants<URBG>; return Generate( g, std::integral_constant<bool, constants::kRangeMask >= (max)()>{}); } -template <typename UIntType, size_t Width> +template <typename UIntType> template <typename URBG> -typename URBG::result_type FastUniformBits<UIntType, Width>::Variate( +typename URBG::result_type FastUniformBits<UIntType>::Variate( URBG& g) { // NOLINT(runtime/references) using constants = FastUniformBitsURBGConstants<URBG>; if (constants::kPowerOfTwo) { @@ -256,10 +238,10 @@ typename URBG::result_type FastUniformBits<UIntType, Width>::Variate( return u; } -template <typename UIntType, size_t Width> +template <typename UIntType> template <typename URBG> -typename FastUniformBits<UIntType, Width>::result_type -FastUniformBits<UIntType, Width>::Generate( +typename FastUniformBits<UIntType>::result_type +FastUniformBits<UIntType>::Generate( URBG& g, // NOLINT(runtime/references) std::true_type /* avoid_looping */) { // The width of the result_type is less than than the width of the random bits @@ -268,10 +250,10 @@ FastUniformBits<UIntType, Width>::Generate( return Variate(g) & (max)(); } -template <typename UIntType, size_t Width> +template <typename UIntType> template <typename URBG> -typename FastUniformBits<UIntType, Width>::result_type -FastUniformBits<UIntType, Width>::Generate( +typename FastUniformBits<UIntType>::result_type +FastUniformBits<UIntType>::Generate( URBG& g, // NOLINT(runtime/references) std::false_type /* avoid_looping */) { // The width of the result_type is wider than the number of random bits @@ -279,7 +261,7 @@ FastUniformBits<UIntType, Width>::Generate( // using a shift and mask. The constants type generates the parameters used // ensure that the bits are distributed across all the invocations of the // underlying URNG. - using constants = FastUniformBitsLoopingConstants<UIntType, Width, URBG>; + using constants = FastUniformBitsLoopingConstants<UIntType, URBG>; result_type s = 0; for (size_t n = 0; n < constants::kN0; ++n) { diff --git a/absl/random/internal/fast_uniform_bits_test.cc b/absl/random/internal/fast_uniform_bits_test.cc index f4b9cd5fcc6d..183779445a52 100644 --- a/absl/random/internal/fast_uniform_bits_test.cc +++ b/absl/random/internal/fast_uniform_bits_test.cc @@ -45,57 +45,6 @@ TYPED_TEST(FastUniformBitsTypedTest, BasicTest) { } } -TEST(FastUniformBitsTest, TypeBoundaries32) { - // Tests that FastUniformBits can adapt to 32-bit boundaries. - absl::random_internal::FastUniformBits<uint32_t, 1> a; - absl::random_internal::FastUniformBits<uint32_t, 31> b; - absl::random_internal::FastUniformBits<uint32_t, 32> c; - - { - std::mt19937 gen; // 32-bit - a(gen); - b(gen); - c(gen); - } - - { - std::mt19937_64 gen; // 64-bit - a(gen); - b(gen); - c(gen); - } -} - -TEST(FastUniformBitsTest, TypeBoundaries64) { - // Tests that FastUniformBits can adapt to 64-bit boundaries. - absl::random_internal::FastUniformBits<uint64_t, 1> a; - absl::random_internal::FastUniformBits<uint64_t, 31> b; - absl::random_internal::FastUniformBits<uint64_t, 32> c; - absl::random_internal::FastUniformBits<uint64_t, 33> d; - absl::random_internal::FastUniformBits<uint64_t, 63> e; - absl::random_internal::FastUniformBits<uint64_t, 64> f; - - { - std::mt19937 gen; // 32-bit - a(gen); - b(gen); - c(gen); - d(gen); - e(gen); - f(gen); - } - - { - std::mt19937_64 gen; // 64-bit - a(gen); - b(gen); - c(gen); - d(gen); - e(gen); - f(gen); - } -} - class UrngOddbits { public: using result_type = uint8_t; @@ -135,18 +84,6 @@ TEST(FastUniformBitsTest, FastUniformBitsDetails) { static_assert(constants::kRangeMask == 0x0f, "constants::kRangeMask == false"); } - { - using looping = FastUniformBitsLoopingConstants<uint32_t, 31, Urng4bits>; - // To get 31 bits from a 4-bit generator, issue 8 calls and extract 4 bits - // per call on all except the first. - static_assert(looping::kN0 == 1, "looping::kN0"); - static_assert(looping::kW0 == 3, "looping::kW0"); - static_assert(looping::kM0 == 0x7, "looping::kM0"); - // (The second set of calls, kN1, will not do anything.) - static_assert(looping::kN1 == 8, "looping::kN1"); - static_assert(looping::kW1 == 4, "looping::kW1"); - static_assert(looping::kM1 == 0xf, "looping::kM1"); - } // ~7-bit URBG { @@ -158,31 +95,6 @@ TEST(FastUniformBitsTest, FastUniformBitsDetails) { static_assert(constants::kRangeMask == 0x7f, "constants::kRangeMask == 0x7f"); } - { - using looping = FastUniformBitsLoopingConstants<uint64_t, 60, UrngOddbits>; - // To get 60 bits from a 7-bit generator, issue 10 calls and extract 6 bits - // per call, discarding the excess entropy. - static_assert(looping::kN0 == 10, "looping::kN0"); - static_assert(looping::kW0 == 6, "looping::kW0"); - static_assert(looping::kM0 == 0x3f, "looping::kM0"); - // (The second set of calls, kN1, will not do anything.) - static_assert(looping::kN1 == 10, "looping::kN1"); - static_assert(looping::kW1 == 7, "looping::kW1"); - static_assert(looping::kM1 == 0x7f, "looping::kM1"); - } - { - using looping = FastUniformBitsLoopingConstants<uint64_t, 63, UrngOddbits>; - // To get 63 bits from a 7-bit generator, issue 10 calls--the same as we - // would issue for 60 bits--however this time we use two groups. The first - // group (kN0) will issue 7 calls, extracting 6 bits per call. - static_assert(looping::kN0 == 7, "looping::kN0"); - static_assert(looping::kW0 == 6, "looping::kW0"); - static_assert(looping::kM0 == 0x3f, "looping::kM0"); - // The second group (kN1) will issue 3 calls, extracting 7 bits per call. - static_assert(looping::kN1 == 10, "looping::kN1"); - static_assert(looping::kW1 == 7, "looping::kW1"); - static_assert(looping::kM1 == 0x7f, "looping::kM1"); - } } TEST(FastUniformBitsTest, Urng4_VariousOutputs) { @@ -193,33 +105,6 @@ TEST(FastUniformBitsTest, Urng4_VariousOutputs) { // 8-bit types { - absl::random_internal::FastUniformBits<uint8_t, 1> fast1; - EXPECT_EQ(0x1, fast1(urng4)); - EXPECT_EQ(0x1, fast1(urng32)); - } - { - absl::random_internal::FastUniformBits<uint8_t, 2> fast2; - EXPECT_EQ(0x1, fast2(urng4)); - EXPECT_EQ(0x1, fast2(urng32)); - } - - { - absl::random_internal::FastUniformBits<uint8_t, 4> fast4; - EXPECT_EQ(0x1, fast4(urng4)); - EXPECT_EQ(0x1, fast4(urng32)); - } - { - absl::random_internal::FastUniformBits<uint8_t, 6> fast6; - EXPECT_EQ(0x9, fast6(urng4)); // b001001 (2x3) - EXPECT_EQ(0x1, fast6(urng32)); - } - { - absl::random_internal::FastUniformBits<uint8_t, 6> fast7; - EXPECT_EQ(0x9, fast7(urng4)); // b00001001 (1x4 + 1x3) - EXPECT_EQ(0x1, fast7(urng32)); - } - - { absl::random_internal::FastUniformBits<uint8_t> fast8; EXPECT_EQ(0x11, fast8(urng4)); EXPECT_EQ(0x1, fast8(urng32)); @@ -227,22 +112,6 @@ TEST(FastUniformBitsTest, Urng4_VariousOutputs) { // 16-bit types { - absl::random_internal::FastUniformBits<uint16_t, 10> fast10; - EXPECT_EQ(0x91, fast10(urng4)); // b 0010010001 (2x3 + 1x4) - EXPECT_EQ(0x1, fast10(urng32)); - } - { - absl::random_internal::FastUniformBits<uint16_t, 11> fast11; - EXPECT_EQ(0x111, fast11(urng4)); - EXPECT_EQ(0x1, fast11(urng32)); - } - { - absl::random_internal::FastUniformBits<uint16_t, 12> fast12; - EXPECT_EQ(0x111, fast12(urng4)); - EXPECT_EQ(0x1, fast12(urng32)); - } - - { absl::random_internal::FastUniformBits<uint16_t> fast16; EXPECT_EQ(0x1111, fast16(urng4)); EXPECT_EQ(0x1, fast16(urng32)); @@ -250,17 +119,6 @@ TEST(FastUniformBitsTest, Urng4_VariousOutputs) { // 32-bit types { - absl::random_internal::FastUniformBits<uint32_t, 21> fast21; - EXPECT_EQ(0x49111, fast21(urng4)); // b 001001001 000100010001 (3x3 + 3x4) - EXPECT_EQ(0x1, fast21(urng32)); - } - { - absl::random_internal::FastUniformBits<uint32_t, 24> fast24; - EXPECT_EQ(0x111111, fast24(urng4)); - EXPECT_EQ(0x1, fast24(urng32)); - } - - { absl::random_internal::FastUniformBits<uint32_t> fast32; EXPECT_EQ(0x11111111, fast32(urng4)); EXPECT_EQ(0x1, fast32(urng32)); @@ -268,19 +126,6 @@ TEST(FastUniformBitsTest, Urng4_VariousOutputs) { // 64-bit types { - absl::random_internal::FastUniformBits<uint64_t, 5> fast5; - EXPECT_EQ(0x9, fast5(urng4)); - EXPECT_EQ(0x1, fast5(urng32)); - } - - { - absl::random_internal::FastUniformBits<uint64_t, 48> fast48; - EXPECT_EQ(0x111111111111, fast48(urng4)); - // computes in 2 steps, should be 24 << 24 - EXPECT_EQ(0x000001000001, fast48(urng32)); - } - - { absl::random_internal::FastUniformBits<uint64_t> fast64; EXPECT_EQ(0x1111111111111111, fast64(urng4)); EXPECT_EQ(0x0000000100000001, fast64(urng32)); |