Export of internal Abseil changes.
-- 9c4ef32276054fba6a116c01cd4b3fd278f59ece by Andy Soffer <asoffer@google.com>: Remove support for unused arbitrary-width output in FastUniformBits. Width should be inferred from the requested return UIntType. PiperOrigin-RevId: 257189319 -- e3326329d02171a301cc3d6ae617ed448472b728 by Abseil Team <absl-team@google.com>: Update comments to make clear that absl::Format(std::string *, ...) appends to the provided string. PiperOrigin-RevId: 257058043 -- e2096b06d714fba3ea2c885d670a42efd872765c by Xiaoyi Zhang <zhangxy@google.com>: Fix compilation error on MSVC 2017. The root cause seems to be a compiler bug in VS 2017 about pack expansion with multiple parameter packs, specifically `MakeVisitationMatrixImpl::Run` is triggering compiler error "error C3528: 'BoundIndices': the number of elements in this pack expansion does not match the number of elements in 'EndIndices'". Work around this issue by using only one parameter pack `CurrIndices` in `MakeVisitationMatrixImpl::Run`. PiperOrigin-RevId: 257040381 -- 9ab75ff27b2513583fffc1233e6568aa96be36f7 by Matt Calabrese <calabrese@google.com>: Internal change. PiperOrigin-RevId: 257039041 GitOrigin-RevId: 9c4ef32276054fba6a116c01cd4b3fd278f59ece Change-Id: I5f708bb03aff93948502394a413260af2a8a273b
This commit is contained in:
		
							parent
							
								
									3c98fcc046
								
							
						
					
					
						commit
						44efe96dfc
					
				
					 5 changed files with 50 additions and 211 deletions
				
			
		|  | @ -257,9 +257,9 @@ void BM_Thread(benchmark::State& state) { | ||||||
|   BENCHMARK_TEMPLATE(BM_ShuffleReuse, Engine, 100);                            \ |   BENCHMARK_TEMPLATE(BM_ShuffleReuse, Engine, 100);                            \ | ||||||
|   BENCHMARK_TEMPLATE(BM_ShuffleReuse, Engine, 1000);                           \ |   BENCHMARK_TEMPLATE(BM_ShuffleReuse, Engine, 1000);                           \ | ||||||
|   BENCHMARK_TEMPLATE(BM_Dist, Engine,                                          \ |   BENCHMARK_TEMPLATE(BM_Dist, Engine,                                          \ | ||||||
|                      absl::random_internal::FastUniformBits<uint32_t, 32>);    \ |                      absl::random_internal::FastUniformBits<uint32_t>);        \ | ||||||
|   BENCHMARK_TEMPLATE(BM_Dist, Engine,                                          \ |   BENCHMARK_TEMPLATE(BM_Dist, Engine,                                          \ | ||||||
|                      absl::random_internal::FastUniformBits<uint64_t, 64>);    \ |                      absl::random_internal::FastUniformBits<uint64_t>);        \ | ||||||
|   BENCHMARK_TEMPLATE(BM_Dist, Engine, std::uniform_int_distribution<int32_t>); \ |   BENCHMARK_TEMPLATE(BM_Dist, Engine, std::uniform_int_distribution<int32_t>); \ | ||||||
|   BENCHMARK_TEMPLATE(BM_Dist, Engine, std::uniform_int_distribution<int64_t>); \ |   BENCHMARK_TEMPLATE(BM_Dist, Engine, std::uniform_int_distribution<int64_t>); \ | ||||||
|   BENCHMARK_TEMPLATE(BM_Dist, Engine,                                          \ |   BENCHMARK_TEMPLATE(BM_Dist, Engine,                                          \ | ||||||
|  |  | ||||||
|  | @ -38,14 +38,12 @@ constexpr typename URBG::result_type constexpr_range() { | ||||||
| // from a type which conforms to the [rand.req.urbg] concept.
 | // from a type which conforms to the [rand.req.urbg] concept.
 | ||||||
| // Parameterized by:
 | // Parameterized by:
 | ||||||
| //  `UIntType`: the result (output) type
 | //  `UIntType`: the result (output) type
 | ||||||
| //  `Width`: binary output width
 |  | ||||||
| //
 | //
 | ||||||
| // The std::independent_bits_engine [rand.adapt.ibits] adaptor can be
 | // The std::independent_bits_engine [rand.adapt.ibits] adaptor can be
 | ||||||
| // instantiated from an existing generator through a copy or a move. It does
 | // 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
 | // not, however, facilitate the production of pseudorandom bits from an un-owned
 | ||||||
| // generator that will outlive the std::independent_bits_engine instance.
 | // generator that will outlive the std::independent_bits_engine instance.
 | ||||||
| template <typename UIntType = uint64_t, | template <typename UIntType = uint64_t> | ||||||
|           size_t Width = std::numeric_limits<UIntType>::digits> |  | ||||||
| class FastUniformBits { | class FastUniformBits { | ||||||
|   static_assert(std::is_unsigned<UIntType>::value, |   static_assert(std::is_unsigned<UIntType>::value, | ||||||
|                 "Class-template FastUniformBits<> must be parameterized using " |                 "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
 |   // `kWidth` is the width, in binary digits, of the output. By default it is
 | ||||||
|   // the number of binary digits in the `result_type`.
 |   // the number of binary digits in the `result_type`.
 | ||||||
|   static constexpr size_t kWidth = Width; |   static constexpr size_t kWidth = std::numeric_limits<UIntType>::digits; | ||||||
|   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; |  | ||||||
|   } |  | ||||||
| 
 | 
 | ||||||
|  public: |  public: | ||||||
|   using result_type = UIntType; |   using result_type = UIntType; | ||||||
| 
 | 
 | ||||||
|   static constexpr result_type(min)() { return 0; } |   static constexpr result_type(min)() { return 0; } | ||||||
|   static constexpr result_type(max)() { |   static constexpr result_type(max)() { | ||||||
|     return kIsMaxWidth ? (std::numeric_limits<result_type>::max)() |     return (std::numeric_limits<result_type>::max)(); | ||||||
|                        : constexpr_mask(kWidth); |  | ||||||
|   } |   } | ||||||
| 
 | 
 | ||||||
|   template <typename URBG> |   template <typename URBG> | ||||||
|  | @ -166,7 +149,6 @@ class FastUniformBitsURBGConstants { | ||||||
| // URBG::result_type values are combined into an output_value.
 | // URBG::result_type values are combined into an output_value.
 | ||||||
| // Parameterized by the FastUniformBits parameters:
 | // Parameterized by the FastUniformBits parameters:
 | ||||||
| //  `UIntType`: output type.
 | //  `UIntType`: output type.
 | ||||||
| //  `Width`: binary output width,
 |  | ||||||
| //  `URNG`: The underlying UniformRandomNumberGenerator.
 | //  `URNG`: The underlying UniformRandomNumberGenerator.
 | ||||||
| //
 | //
 | ||||||
| // The looping constants describe the sets of loop counters and mask values
 | // The looping constants describe the sets of loop counters and mask values
 | ||||||
|  | @ -177,10 +159,10 @@ class FastUniformBitsURBGConstants { | ||||||
| // bit per variate.
 | // bit per variate.
 | ||||||
| //
 | //
 | ||||||
| // See [rand.adapt.ibits] for more details on the use of these constants.
 | // 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 { | class FastUniformBitsLoopingConstants { | ||||||
|  private: |  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 urbg_result_type = typename URBG::result_type; | ||||||
|   using uint_result_type = UIntType; |   using uint_result_type = UIntType; | ||||||
| 
 | 
 | ||||||
|  | @ -229,19 +211,19 @@ class FastUniformBitsLoopingConstants { | ||||||
|       "Class-template FastUniformBitsLoopingConstants::kW0 too small."); |       "Class-template FastUniformBitsLoopingConstants::kW0 too small."); | ||||||
| }; | }; | ||||||
| 
 | 
 | ||||||
| template <typename UIntType, size_t Width> | template <typename UIntType> | ||||||
| template <typename URBG> | template <typename URBG> | ||||||
| typename FastUniformBits<UIntType, Width>::result_type | typename FastUniformBits<UIntType>::result_type | ||||||
| FastUniformBits<UIntType, Width>::operator()( | FastUniformBits<UIntType>::operator()( | ||||||
|     URBG& g) {  // NOLINT(runtime/references)
 |     URBG& g) {  // NOLINT(runtime/references)
 | ||||||
|   using constants = FastUniformBitsURBGConstants<URBG>; |   using constants = FastUniformBitsURBGConstants<URBG>; | ||||||
|   return Generate( |   return Generate( | ||||||
|       g, std::integral_constant<bool, constants::kRangeMask >= (max)()>{}); |       g, std::integral_constant<bool, constants::kRangeMask >= (max)()>{}); | ||||||
| } | } | ||||||
| 
 | 
 | ||||||
| template <typename UIntType, size_t Width> | template <typename UIntType> | ||||||
| template <typename URBG> | template <typename URBG> | ||||||
| typename URBG::result_type FastUniformBits<UIntType, Width>::Variate( | typename URBG::result_type FastUniformBits<UIntType>::Variate( | ||||||
|     URBG& g) {  // NOLINT(runtime/references)
 |     URBG& g) {  // NOLINT(runtime/references)
 | ||||||
|   using constants = FastUniformBitsURBGConstants<URBG>; |   using constants = FastUniformBitsURBGConstants<URBG>; | ||||||
|   if (constants::kPowerOfTwo) { |   if (constants::kPowerOfTwo) { | ||||||
|  | @ -256,10 +238,10 @@ typename URBG::result_type FastUniformBits<UIntType, Width>::Variate( | ||||||
|   return u; |   return u; | ||||||
| } | } | ||||||
| 
 | 
 | ||||||
| template <typename UIntType, size_t Width> | template <typename UIntType> | ||||||
| template <typename URBG> | template <typename URBG> | ||||||
| typename FastUniformBits<UIntType, Width>::result_type | typename FastUniformBits<UIntType>::result_type | ||||||
| FastUniformBits<UIntType, Width>::Generate( | FastUniformBits<UIntType>::Generate( | ||||||
|     URBG& g,  // NOLINT(runtime/references)
 |     URBG& g,  // NOLINT(runtime/references)
 | ||||||
|     std::true_type /* avoid_looping */) { |     std::true_type /* avoid_looping */) { | ||||||
|   // The width of the result_type is less than than the width of the random bits
 |   // 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)(); |   return Variate(g) & (max)(); | ||||||
| } | } | ||||||
| 
 | 
 | ||||||
| template <typename UIntType, size_t Width> | template <typename UIntType> | ||||||
| template <typename URBG> | template <typename URBG> | ||||||
| typename FastUniformBits<UIntType, Width>::result_type | typename FastUniformBits<UIntType>::result_type | ||||||
| FastUniformBits<UIntType, Width>::Generate( | FastUniformBits<UIntType>::Generate( | ||||||
|     URBG& g,  // NOLINT(runtime/references)
 |     URBG& g,  // NOLINT(runtime/references)
 | ||||||
|     std::false_type /* avoid_looping */) { |     std::false_type /* avoid_looping */) { | ||||||
|   // The width of the result_type is wider than the number of random bits
 |   // 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
 |   // using a shift and mask.  The constants type generates the parameters used
 | ||||||
|   // ensure that the bits are distributed across all the invocations of the
 |   // ensure that the bits are distributed across all the invocations of the
 | ||||||
|   // underlying URNG.
 |   // underlying URNG.
 | ||||||
|   using constants = FastUniformBitsLoopingConstants<UIntType, Width, URBG>; |   using constants = FastUniformBitsLoopingConstants<UIntType, URBG>; | ||||||
| 
 | 
 | ||||||
|   result_type s = 0; |   result_type s = 0; | ||||||
|   for (size_t n = 0; n < constants::kN0; ++n) { |   for (size_t n = 0; n < constants::kN0; ++n) { | ||||||
|  |  | ||||||
|  | @ -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 { | class UrngOddbits { | ||||||
|  public: |  public: | ||||||
|   using result_type = uint8_t; |   using result_type = uint8_t; | ||||||
|  | @ -135,18 +84,6 @@ TEST(FastUniformBitsTest, FastUniformBitsDetails) { | ||||||
|     static_assert(constants::kRangeMask == 0x0f, |     static_assert(constants::kRangeMask == 0x0f, | ||||||
|                   "constants::kRangeMask == false"); |                   "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
 |   // ~7-bit URBG
 | ||||||
|   { |   { | ||||||
|  | @ -158,31 +95,6 @@ TEST(FastUniformBitsTest, FastUniformBitsDetails) { | ||||||
|     static_assert(constants::kRangeMask == 0x7f, |     static_assert(constants::kRangeMask == 0x7f, | ||||||
|                   "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) { | TEST(FastUniformBitsTest, Urng4_VariousOutputs) { | ||||||
|  | @ -192,33 +104,6 @@ TEST(FastUniformBitsTest, Urng4_VariousOutputs) { | ||||||
|   Urng32bits urng32; |   Urng32bits urng32; | ||||||
| 
 | 
 | ||||||
|   // 8-bit types
 |   // 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; |     absl::random_internal::FastUniformBits<uint8_t> fast8; | ||||||
|     EXPECT_EQ(0x11, fast8(urng4)); |     EXPECT_EQ(0x11, fast8(urng4)); | ||||||
|  | @ -226,22 +111,6 @@ TEST(FastUniformBitsTest, Urng4_VariousOutputs) { | ||||||
|   } |   } | ||||||
| 
 | 
 | ||||||
|   // 16-bit types
 |   // 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; |     absl::random_internal::FastUniformBits<uint16_t> fast16; | ||||||
|     EXPECT_EQ(0x1111, fast16(urng4)); |     EXPECT_EQ(0x1111, fast16(urng4)); | ||||||
|  | @ -249,17 +118,6 @@ TEST(FastUniformBitsTest, Urng4_VariousOutputs) { | ||||||
|   } |   } | ||||||
| 
 | 
 | ||||||
|   // 32-bit types
 |   // 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; |     absl::random_internal::FastUniformBits<uint32_t> fast32; | ||||||
|     EXPECT_EQ(0x11111111, fast32(urng4)); |     EXPECT_EQ(0x11111111, fast32(urng4)); | ||||||
|  | @ -267,19 +125,6 @@ TEST(FastUniformBitsTest, Urng4_VariousOutputs) { | ||||||
|   } |   } | ||||||
| 
 | 
 | ||||||
|   // 64-bit types
 |   // 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; |     absl::random_internal::FastUniformBits<uint64_t> fast64; | ||||||
|     EXPECT_EQ(0x1111111111111111, fast64(urng4)); |     EXPECT_EQ(0x1111111111111111, fast64(urng4)); | ||||||
|  |  | ||||||
|  | @ -449,7 +449,7 @@ class FormatRawSink { | ||||||
| // additional arguments.
 | // additional arguments.
 | ||||||
| //
 | //
 | ||||||
| // By default, `std::string` and `std::ostream` are supported as destination
 | // By default, `std::string` and `std::ostream` are supported as destination
 | ||||||
| // objects.
 | // objects. If a `std::string` is used the formatted string is appended to it.
 | ||||||
| //
 | //
 | ||||||
| // `absl::Format()` is a generic version of `absl::StrFormat(), for custom
 | // `absl::Format()` is a generic version of `absl::StrFormat(), for custom
 | ||||||
| // sinks. The format string, like format strings for `StrFormat()`, is checked
 | // sinks. The format string, like format strings for `StrFormat()`, is checked
 | ||||||
|  |  | ||||||
|  | @ -204,7 +204,7 @@ template <class Op, class... Vs> | ||||||
| using VisitIndicesResultT = typename VisitIndicesResultImpl<Op, Vs...>::type; | using VisitIndicesResultT = typename VisitIndicesResultImpl<Op, Vs...>::type; | ||||||
| 
 | 
 | ||||||
| template <class ReturnType, class FunctionObject, class EndIndices, | template <class ReturnType, class FunctionObject, class EndIndices, | ||||||
|           std::size_t... BoundIndices> |           class BoundIndices> | ||||||
| struct MakeVisitationMatrix; | struct MakeVisitationMatrix; | ||||||
| 
 | 
 | ||||||
| template <class ReturnType, class FunctionObject, std::size_t... Indices> | template <class ReturnType, class FunctionObject, std::size_t... Indices> | ||||||
|  | @ -218,7 +218,7 @@ constexpr ReturnType call_with_indices(FunctionObject&& function) { | ||||||
| 
 | 
 | ||||||
| template <class ReturnType, class FunctionObject, std::size_t... BoundIndices> | template <class ReturnType, class FunctionObject, std::size_t... BoundIndices> | ||||||
| struct MakeVisitationMatrix<ReturnType, FunctionObject, index_sequence<>, | struct MakeVisitationMatrix<ReturnType, FunctionObject, index_sequence<>, | ||||||
|                             BoundIndices...> { |                             index_sequence<BoundIndices...>> { | ||||||
|   using ResultType = ReturnType (*)(FunctionObject&&); |   using ResultType = ReturnType (*)(FunctionObject&&); | ||||||
|   static constexpr ResultType Run() { |   static constexpr ResultType Run() { | ||||||
|     return &call_with_indices<ReturnType, FunctionObject, |     return &call_with_indices<ReturnType, FunctionObject, | ||||||
|  | @ -226,24 +226,34 @@ struct MakeVisitationMatrix<ReturnType, FunctionObject, index_sequence<>, | ||||||
|   } |   } | ||||||
| }; | }; | ||||||
| 
 | 
 | ||||||
|  | template <typename Is, std::size_t J> | ||||||
|  | struct AppendToIndexSequence; | ||||||
|  | 
 | ||||||
|  | template <typename Is, std::size_t J> | ||||||
|  | using AppendToIndexSequenceT = typename AppendToIndexSequence<Is, J>::type; | ||||||
|  | 
 | ||||||
|  | template <std::size_t... Is, std::size_t J> | ||||||
|  | struct AppendToIndexSequence<index_sequence<Is...>, J> { | ||||||
|  |   using type = index_sequence<Is..., J>; | ||||||
|  | }; | ||||||
|  | 
 | ||||||
| template <class ReturnType, class FunctionObject, class EndIndices, | template <class ReturnType, class FunctionObject, class EndIndices, | ||||||
|           class CurrIndices, std::size_t... BoundIndices> |           class CurrIndices, class BoundIndices> | ||||||
| struct MakeVisitationMatrixImpl; | struct MakeVisitationMatrixImpl; | ||||||
| 
 | 
 | ||||||
| template <class ReturnType, class FunctionObject, std::size_t... EndIndices, | template <class ReturnType, class FunctionObject, class EndIndices, | ||||||
|           std::size_t... CurrIndices, std::size_t... BoundIndices> |           std::size_t... CurrIndices, class BoundIndices> | ||||||
| struct MakeVisitationMatrixImpl< | struct MakeVisitationMatrixImpl<ReturnType, FunctionObject, EndIndices, | ||||||
|     ReturnType, FunctionObject, index_sequence<EndIndices...>, |                                 index_sequence<CurrIndices...>, BoundIndices> { | ||||||
|     index_sequence<CurrIndices...>, BoundIndices...> { |  | ||||||
|   using ResultType = SimpleArray< |   using ResultType = SimpleArray< | ||||||
|       typename MakeVisitationMatrix<ReturnType, FunctionObject, |       typename MakeVisitationMatrix<ReturnType, FunctionObject, EndIndices, | ||||||
|                                     index_sequence<EndIndices...>>::ResultType, |                                     index_sequence<>>::ResultType, | ||||||
|       sizeof...(CurrIndices)>; |       sizeof...(CurrIndices)>; | ||||||
| 
 | 
 | ||||||
|   static constexpr ResultType Run() { |   static constexpr ResultType Run() { | ||||||
|     return {{MakeVisitationMatrix<ReturnType, FunctionObject, |     return {{MakeVisitationMatrix< | ||||||
|                                   index_sequence<EndIndices...>, |         ReturnType, FunctionObject, EndIndices, | ||||||
|                                   BoundIndices..., CurrIndices>::Run()...}}; |         AppendToIndexSequenceT<BoundIndices, CurrIndices>>::Run()...}}; | ||||||
|   } |   } | ||||||
| }; | }; | ||||||
| 
 | 
 | ||||||
|  | @ -251,10 +261,11 @@ template <class ReturnType, class FunctionObject, std::size_t HeadEndIndex, | ||||||
|           std::size_t... TailEndIndices, std::size_t... BoundIndices> |           std::size_t... TailEndIndices, std::size_t... BoundIndices> | ||||||
| struct MakeVisitationMatrix<ReturnType, FunctionObject, | struct MakeVisitationMatrix<ReturnType, FunctionObject, | ||||||
|                             index_sequence<HeadEndIndex, TailEndIndices...>, |                             index_sequence<HeadEndIndex, TailEndIndices...>, | ||||||
|                             BoundIndices...> |                             index_sequence<BoundIndices...>> | ||||||
|     : MakeVisitationMatrixImpl< |     : MakeVisitationMatrixImpl<ReturnType, FunctionObject, | ||||||
|           ReturnType, FunctionObject, index_sequence<TailEndIndices...>, |                                index_sequence<TailEndIndices...>, | ||||||
|           absl::make_index_sequence<HeadEndIndex>, BoundIndices...> {}; |                                absl::make_index_sequence<HeadEndIndex>, | ||||||
|  |                                index_sequence<BoundIndices...>> {}; | ||||||
| 
 | 
 | ||||||
| struct UnreachableSwitchCase { | struct UnreachableSwitchCase { | ||||||
|   template <class Op> |   template <class Op> | ||||||
|  | @ -423,7 +434,8 @@ struct VisitIndicesFallback { | ||||||
|   static VisitIndicesResultT<Op, SizeT...> Run(Op&& op, SizeT... indices) { |   static VisitIndicesResultT<Op, SizeT...> Run(Op&& op, SizeT... indices) { | ||||||
|     return AccessSimpleArray( |     return AccessSimpleArray( | ||||||
|         MakeVisitationMatrix<VisitIndicesResultT<Op, SizeT...>, Op, |         MakeVisitationMatrix<VisitIndicesResultT<Op, SizeT...>, Op, | ||||||
|                              index_sequence<(EndIndices + 1)...>>::Run(), |                              index_sequence<(EndIndices + 1)...>, | ||||||
|  |                              index_sequence<>>::Run(), | ||||||
|         (indices + 1)...)(absl::forward<Op>(op)); |         (indices + 1)...)(absl::forward<Op>(op)); | ||||||
|   } |   } | ||||||
| }; | }; | ||||||
|  |  | ||||||
		Loading…
	
	Add table
		Add a link
		
	
		Reference in a new issue