276 lines
10 KiB
C
276 lines
10 KiB
C
|
// 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/fast_uniform_bits.h"
|
||
|
|
#include "absl/random/internal/iostream_state_saver.h"
|
||
|
|
#include "absl/random/internal/traits.h"
|
||
|
|
#include "absl/random/internal/wide_multiply.h"
|
||
|
|
|
||
|
|
namespace absl {
|
||
|
|
ABSL_NAMESPACE_BEGIN
|
||
|
|
|
||
|
|
// 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);
|
||
|
|
}
|
||
|
|
|
||
|
|
ABSL_NAMESPACE_END
|
||
|
|
} // namespace absl
|
||
|
|
|
||
|
|
#endif // ABSL_RANDOM_UNIFORM_INT_DISTRIBUTION_H_
|