tvl-depot/absl/random/uniform_int_distribution.h

274 lines
10 KiB
C
Raw Normal View History

Export of internal Abseil changes. -- 7a6ff16a85beb730c172d5d25cf1b5e1be885c56 by Laramie Leavitt <lar@google.com>: Internal change. PiperOrigin-RevId: 254454546 -- ff8f9bafaefc26d451f576ea4a06d150aed63f6f by Andy Soffer <asoffer@google.com>: Internal changes PiperOrigin-RevId: 254451562 -- deefc5b651b479ce36f0b4ef203e119c0c8936f2 by CJ Johnson <johnsoncj@google.com>: Account for subtracting unsigned values from the size of InlinedVector PiperOrigin-RevId: 254450625 -- 3c677316a27bcadc17e41957c809ca472d5fef14 by Andy Soffer <asoffer@google.com>: Add C++17's std::make_from_tuple to absl/utility/utility.h PiperOrigin-RevId: 254411573 -- 4ee3536a918830eeec402a28fc31a62c7c90b940 by CJ Johnson <johnsoncj@google.com>: Adds benchmark for the rest of the InlinedVector public API PiperOrigin-RevId: 254408378 -- e5a21a00700ee83498ff1efbf649169756463ee4 by CJ Johnson <johnsoncj@google.com>: Updates the definition of InlinedVector::shrink_to_fit() to be exception safe and adds exception safety tests for it. PiperOrigin-RevId: 254401387 -- 2ea82e72b86d82d78b4e4712a63a55981b53c64b by Laramie Leavitt <lar@google.com>: Use absl::InsecureBitGen in place of std::mt19937 in tests absl/random/...distribution_test.cc PiperOrigin-RevId: 254289444 -- fa099e02c413a7ffda732415e8105cad26a90337 by Andy Soffer <asoffer@google.com>: Internal changes PiperOrigin-RevId: 254286334 -- ce34b7f36933b30cfa35b9c9a5697a792b5666e4 by Andy Soffer <asoffer@google.com>: Internal changes PiperOrigin-RevId: 254273059 -- 6f9c473da7c2090c2e85a37c5f00622e8a912a89 by Jorg Brown <jorg@google.com>: Change absl::container_internal::CompressedTuple to instantiate its internal Storage class with the name of the type it's holding, rather than the name of the Tuple. This is not an externally-visible change, other than less compiler memory is used and less debug information is generated. PiperOrigin-RevId: 254269285 -- 8bd3c186bf2fc0c55d8a2dd6f28a5327502c9fba by Andy Soffer <asoffer@google.com>: Adding short-hand IntervalClosed for IntervalClosedClosed and IntervalOpen for IntervalOpenOpen. PiperOrigin-RevId: 254252419 -- ea957f99b6a04fccd42aa05605605f3b44b1ecfd by Abseil Team <absl-team@google.com>: Do not directly use __SIZEOF_INT128__. In order to avoid linker errors when building with clang-cl (__fixunsdfti, __udivti3 and __fixunssfti are undefined), this CL uses ABSL_HAVE_INTRINSIC_INT128 which is not defined for clang-cl. PiperOrigin-RevId: 254250739 -- 89ab385cd26b34d64130bce856253aaba96d2345 by Andy Soffer <asoffer@google.com>: Internal changes PiperOrigin-RevId: 254242321 -- cffc793d93eca6d6bdf7de733847b6ab4a255ae9 by CJ Johnson <johnsoncj@google.com>: Adds benchmark for InlinedVector::reserve(size_type) PiperOrigin-RevId: 254199226 -- c90c7a9fa3c8f0c9d5114036979548b055ea2f2a by Gennadiy Rozental <rogeeff@google.com>: Import of CCTZ from GitHub. PiperOrigin-RevId: 254072387 -- c4c388beae016c9570ab54ffa1d52660e4a85b7b by Laramie Leavitt <lar@google.com>: Internal cleanup. PiperOrigin-RevId: 254062381 -- d3c992e221cc74e5372d0c8fa410170b6a43c062 by Tom Manshreck <shreck@google.com>: Update distributions.h to Abseil standards PiperOrigin-RevId: 254054946 -- d15ad0035c34ef11b14fadc5a4a2d3ec415f5518 by CJ Johnson <johnsoncj@google.com>: Removes functions with only one caller from the implementation details of InlinedVector by manually inlining the definitions PiperOrigin-RevId: 254005427 -- 2f37e807efc3a8ef1f4b539bdd379917d4151520 by Andy Soffer <asoffer@google.com>: Initial release of Abseil Random PiperOrigin-RevId: 253999861 -- 24ed1694b6430791d781ed533a8f8ccf6cac5856 by CJ Johnson <johnsoncj@google.com>: Updates the definition of InlinedVector::assign(...)/InlinedVector::operator=(...) to new, exception-safe implementations with exception safety tests to boot PiperOrigin-RevId: 253993691 -- 5613d95f5a7e34a535cfaeadce801441e990843e by CJ Johnson <johnsoncj@google.com>: Adds benchmarks for InlinedVector::shrink_to_fit() PiperOrigin-RevId: 253989647 -- 2a96ddfdac40bbb8cb6a7f1aeab90917067c6e63 by Abseil Team <absl-team@google.com>: Initial release of Abseil Random PiperOrigin-RevId: 253927497 -- bf1aff8fc9ffa921ad74643e9525ecf25b0d8dc1 by Andy Soffer <asoffer@google.com>: Initial release of Abseil Random PiperOrigin-RevId: 253920512 -- bfc03f4a3dcda3cf3a4b84bdb84cda24e3394f41 by Laramie Leavitt <lar@google.com>: Internal change. PiperOrigin-RevId: 253886486 -- 05036cfcc078ca7c5f581a00dfb0daed568cbb69 by Eric Fiselier <ericwf@google.com>: Don't include `winsock2.h` because it drags in `windows.h` and friends, and they define awful macros like OPAQUE, ERROR, and more. This has the potential to break abseil users. Instead we only forward declare `timeval` and require Windows users include `winsock2.h` themselves. This is both inconsistent and poor QoI, but so including 'windows.h' is bad too. PiperOrigin-RevId: 253852615 GitOrigin-RevId: 7a6ff16a85beb730c172d5d25cf1b5e1be885c56 Change-Id: Icd6aff87da26f29ec8915da856f051129987cef6
2019-06-21 22:11:42 +02:00
// Copyright 2017 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// -----------------------------------------------------------------------------
// File: uniform_int_distribution.h
// -----------------------------------------------------------------------------
//
// This header defines a class for representing a uniform integer distribution
// over the closed (inclusive) interval [a,b]. You use this distribution in
// combination with an Abseil random bit generator to produce random values
// according to the rules of the distribution.
//
// `absl::uniform_int_distribution` is a drop-in replacement for the C++11
// `std::uniform_int_distribution` [rand.dist.uni.int] but is considerably
// faster than the libstdc++ implementation.
#ifndef ABSL_RANDOM_UNIFORM_INT_DISTRIBUTION_H_
#define ABSL_RANDOM_UNIFORM_INT_DISTRIBUTION_H_
#include <cassert>
#include <istream>
#include <limits>
#include <type_traits>
#include "absl/base/optimization.h"
#include "absl/random/internal/distribution_impl.h"
#include "absl/random/internal/fast_uniform_bits.h"
#include "absl/random/internal/iostream_state_saver.h"
#include "absl/random/internal/traits.h"
namespace absl {
// absl::uniform_int_distribution<T>
//
// This distribution produces random integer values uniformly distributed in the
// closed (inclusive) interval [a, b].
//
// Example:
//
// absl::BitGen gen;
//
// // Use the distribution to produce a value between 1 and 6, inclusive.
// int die_roll = absl::uniform_int_distribution<int>(1, 6)(gen);
//
template <typename IntType = int>
class uniform_int_distribution {
private:
using unsigned_type =
typename random_internal::make_unsigned_bits<IntType>::type;
public:
using result_type = IntType;
class param_type {
public:
using distribution_type = uniform_int_distribution;
explicit param_type(
result_type lo = 0,
result_type hi = (std::numeric_limits<result_type>::max)())
: lo_(lo),
range_(static_cast<unsigned_type>(hi) -
static_cast<unsigned_type>(lo)) {
// [rand.dist.uni.int] precondition 2
assert(lo <= hi);
}
result_type a() const { return lo_; }
result_type b() const {
return static_cast<result_type>(static_cast<unsigned_type>(lo_) + range_);
}
friend bool operator==(const param_type& a, const param_type& b) {
return a.lo_ == b.lo_ && a.range_ == b.range_;
}
friend bool operator!=(const param_type& a, const param_type& b) {
return !(a == b);
}
private:
friend class uniform_int_distribution;
unsigned_type range() const { return range_; }
result_type lo_;
unsigned_type range_;
static_assert(std::is_integral<result_type>::value,
"Class-template absl::uniform_int_distribution<> must be "
"parameterized using an integral type.");
}; // param_type
uniform_int_distribution() : uniform_int_distribution(0) {}
explicit uniform_int_distribution(
result_type lo,
result_type hi = (std::numeric_limits<result_type>::max)())
: param_(lo, hi) {}
explicit uniform_int_distribution(const param_type& param) : param_(param) {}
// uniform_int_distribution<T>::reset()
//
// Resets the uniform int distribution. Note that this function has no effect
// because the distribution already produces independent values.
void reset() {}
template <typename URBG>
result_type operator()(URBG& gen) { // NOLINT(runtime/references)
return (*this)(gen, param());
}
template <typename URBG>
result_type operator()(
URBG& gen, const param_type& param) { // NOLINT(runtime/references)
return param.a() + Generate(gen, param.range());
}
result_type a() const { return param_.a(); }
result_type b() const { return param_.b(); }
param_type param() const { return param_; }
void param(const param_type& params) { param_ = params; }
result_type(min)() const { return a(); }
result_type(max)() const { return b(); }
friend bool operator==(const uniform_int_distribution& a,
const uniform_int_distribution& b) {
return a.param_ == b.param_;
}
friend bool operator!=(const uniform_int_distribution& a,
const uniform_int_distribution& b) {
return !(a == b);
}
private:
// Generates a value in the *closed* interval [0, R]
template <typename URBG>
unsigned_type Generate(URBG& g, // NOLINT(runtime/references)
unsigned_type R);
param_type param_;
};
// -----------------------------------------------------------------------------
// Implementation details follow
// -----------------------------------------------------------------------------
template <typename CharT, typename Traits, typename IntType>
std::basic_ostream<CharT, Traits>& operator<<(
std::basic_ostream<CharT, Traits>& os,
const uniform_int_distribution<IntType>& x) {
using stream_type =
typename random_internal::stream_format_type<IntType>::type;
auto saver = random_internal::make_ostream_state_saver(os);
os << static_cast<stream_type>(x.a()) << os.fill()
<< static_cast<stream_type>(x.b());
return os;
}
template <typename CharT, typename Traits, typename IntType>
std::basic_istream<CharT, Traits>& operator>>(
std::basic_istream<CharT, Traits>& is,
uniform_int_distribution<IntType>& x) {
using param_type = typename uniform_int_distribution<IntType>::param_type;
using result_type = typename uniform_int_distribution<IntType>::result_type;
using stream_type =
typename random_internal::stream_format_type<IntType>::type;
stream_type a;
stream_type b;
auto saver = random_internal::make_istream_state_saver(is);
is >> a >> b;
if (!is.fail()) {
x.param(
param_type(static_cast<result_type>(a), static_cast<result_type>(b)));
}
return is;
}
template <typename IntType>
template <typename URBG>
typename random_internal::make_unsigned_bits<IntType>::type
uniform_int_distribution<IntType>::Generate(
URBG& g, // NOLINT(runtime/references)
typename random_internal::make_unsigned_bits<IntType>::type R) {
random_internal::FastUniformBits<unsigned_type> fast_bits;
unsigned_type bits = fast_bits(g);
const unsigned_type Lim = R + 1;
if ((R & Lim) == 0) {
// If the interval's length is a power of two range, just take the low bits.
return bits & R;
}
// Generates a uniform variate on [0, Lim) using fixed-point multiplication.
// The above fast-path guarantees that Lim is representable in unsigned_type.
//
// Algorithm adapted from
// http://lemire.me/blog/2016/06/30/fast-random-shuffling/, with added
// explanation.
//
// The algorithm creates a uniform variate `bits` in the interval [0, 2^N),
// and treats it as the fractional part of a fixed-point real value in [0, 1),
// multiplied by 2^N. For example, 0.25 would be represented as 2^(N - 2),
// because 2^N * 0.25 == 2^(N - 2).
//
// Next, `bits` and `Lim` are multiplied with a wide-multiply to bring the
// value into the range [0, Lim). The integral part (the high word of the
// multiplication result) is then very nearly the desired result. However,
// this is not quite accurate; viewing the multiplication result as one
// double-width integer, the resulting values for the sample are mapped as
// follows:
//
// If the result lies in this interval: Return this value:
// [0, 2^N) 0
// [2^N, 2 * 2^N) 1
// ... ...
// [K * 2^N, (K + 1) * 2^N) K
// ... ...
// [(Lim - 1) * 2^N, Lim * 2^N) Lim - 1
//
// While all of these intervals have the same size, the result of `bits * Lim`
// must be a multiple of `Lim`, and not all of these intervals contain the
// same number of multiples of `Lim`. In particular, some contain
// `F = floor(2^N / Lim)` and some contain `F + 1 = ceil(2^N / Lim)`. This
// difference produces a small nonuniformity, which is corrected by applying
// rejection sampling to one of the values in the "larger intervals" (i.e.,
// the intervals containing `F + 1` multiples of `Lim`.
//
// An interval contains `F + 1` multiples of `Lim` if and only if its smallest
// value modulo 2^N is less than `2^N % Lim`. The unique value satisfying
// this property is used as the one for rejection. That is, a value of
// `bits * Lim` is rejected if `(bit * Lim) % 2^N < (2^N % Lim)`.
using helper = random_internal::wide_multiply<unsigned_type>;
auto product = helper::multiply(bits, Lim);
// Two optimizations here:
// * Rejection occurs with some probability less than 1/2, and for reasonable
// ranges considerably less (in particular, less than 1/(F+1)), so
// ABSL_PREDICT_FALSE is apt.
// * `Lim` is an overestimate of `threshold`, and doesn't require a divide.
if (ABSL_PREDICT_FALSE(helper::lo(product) < Lim)) {
// This quantity is exactly equal to `2^N % Lim`, but does not require high
// precision calculations: `2^N % Lim` is congruent to `(2^N - Lim) % Lim`.
// Ideally this could be expressed simply as `-X` rather than `2^N - X`, but
// for types smaller than int, this calculation is incorrect due to integer
// promotion rules.
const unsigned_type threshold =
((std::numeric_limits<unsigned_type>::max)() - Lim + 1) % Lim;
while (helper::lo(product) < threshold) {
bits = fast_bits(g);
product = helper::multiply(bits, Lim);
}
}
return helper::hi(product);
}
} // namespace absl
#endif // ABSL_RANDOM_UNIFORM_INT_DISTRIBUTION_H_