maurice/snix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Export of internal Abseil changes.

Browse source 
--
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:
Abseil Team 2019-07-09 07:37:37 -07:00 • committed by Matt Calabrese
parent 3c98fcc046
commit 44efe96dfc
5 changed files with 50 additions and 211 deletions
Download patch file Download diff file Expand all files Collapse all files

52
absl/random/internal/fast_uniform_bits.h
View file

@ -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) {