legacy-libs/grpc-cloned/deps/grpc/third_party/abseil-cpp/absl/random/uniform_int_distribution.h

   1 // Copyright 2017 The Abseil Authors.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //      https://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14 //
  15 // -----------------------------------------------------------------------------
  16 // File: uniform_int_distribution.h
  17 // -----------------------------------------------------------------------------
  18 //
  19 // This header defines a class for representing a uniform integer distribution
  20 // over the closed (inclusive) interval [a,b]. You use this distribution in
  21 // combination with an Abseil random bit generator to produce random values
  22 // according to the rules of the distribution.
  23 //
  24 // `absl::uniform_int_distribution` is a drop-in replacement for the C++11
  25 // `std::uniform_int_distribution` [rand.dist.uni.int] but is considerably
  26 // faster than the libstdc++ implementation.
  27
  28 #ifndef ABSL_RANDOM_UNIFORM_INT_DISTRIBUTION_H_
  29 #define ABSL_RANDOM_UNIFORM_INT_DISTRIBUTION_H_
  30
  31 #include <cassert>
  32 #include <istream>
  33 #include <limits>
  34 #include <type_traits>
  35
  36 #include "absl/base/optimization.h"
  37 #include "absl/random/internal/distribution_impl.h"
  38 #include "absl/random/internal/fast_uniform_bits.h"
  39 #include "absl/random/internal/iostream_state_saver.h"
  40 #include "absl/random/internal/traits.h"
  41
  42 namespace absl {
  43
  44 // absl::uniform_int_distribution<T>
  45 //
  46 // This distribution produces random integer values uniformly distributed in the
  47 // closed (inclusive) interval [a, b].
  48 //
  49 // Example:
  50 //
  51 //   absl::BitGen gen;
  52 //
  53 //   // Use the distribution to produce a value between 1 and 6, inclusive.
  54 //   int die_roll = absl::uniform_int_distribution<int>(1, 6)(gen);
  55 //
  56 template <typename IntType = int>
  57 class uniform_int_distribution {
  58  private:
  59   using unsigned_type =
  60       typename random_internal::make_unsigned_bits<IntType>::type;
  61
  62  public:
  63   using result_type = IntType;
  64
  65   class param_type {
  66    public:
  67     using distribution_type = uniform_int_distribution;
  68
  69     explicit param_type(
  70         result_type lo = 0,
  71         result_type hi = (std::numeric_limits<result_type>::max)())
  72         : lo_(lo),
  73           range_(static_cast<unsigned_type>(hi) -
  74                  static_cast<unsigned_type>(lo)) {
  75       // [rand.dist.uni.int] precondition 2
  76       assert(lo <= hi);
  77     }
  78
  79     result_type a() const { return lo_; }
  80     result_type b() const {
  81       return static_cast<result_type>(static_cast<unsigned_type>(lo_) + range_);
  82     }
  83
  84     friend bool operator==(const param_type& a, const param_type& b) {
  85       return a.lo_ == b.lo_ && a.range_ == b.range_;
  86     }
  87
  88     friend bool operator!=(const param_type& a, const param_type& b) {
  89       return !(a == b);
  90     }
  91
  92    private:
  93     friend class uniform_int_distribution;
  94     unsigned_type range() const { return range_; }
  95
  96     result_type lo_;
  97     unsigned_type range_;
  98
  99     static_assert(std::is_integral<result_type>::value,
 100                   "Class-template absl::uniform_int_distribution<> must be "
 101                   "parameterized using an integral type.");
 102   };  // param_type
 103
 104   uniform_int_distribution() : uniform_int_distribution(0) {}
 105
 106   explicit uniform_int_distribution(
 107       result_type lo,
 108       result_type hi = (std::numeric_limits<result_type>::max)())
 109       : param_(lo, hi) {}
 110
 111   explicit uniform_int_distribution(const param_type& param) : param_(param) {}
 112
 113   // uniform_int_distribution<T>::reset()
 114   //
 115   // Resets the uniform int distribution. Note that this function has no effect
 116   // because the distribution already produces independent values.
 117   void reset() {}
 118
 119   template <typename URBG>
 120   result_type operator()(URBG& gen) {  // NOLINT(runtime/references)
 121     return (*this)(gen, param());
 122   }
 123
 124   template <typename URBG>
 125   result_type operator()(
 126       URBG& gen, const param_type& param) {  // NOLINT(runtime/references)
 127     return param.a() + Generate(gen, param.range());
 128   }
 129
 130   result_type a() const { return param_.a(); }
 131   result_type b() const { return param_.b(); }
 132
 133   param_type param() const { return param_; }
 134   void param(const param_type& params) { param_ = params; }
 135
 136   result_type(min)() const { return a(); }
 137   result_type(max)() const { return b(); }
 138
 139   friend bool operator==(const uniform_int_distribution& a,
 140                          const uniform_int_distribution& b) {
 141     return a.param_ == b.param_;
 142   }
 143   friend bool operator!=(const uniform_int_distribution& a,
 144                          const uniform_int_distribution& b) {
 145     return !(a == b);
 146   }
 147
 148  private:
 149   // Generates a value in the *closed* interval [0, R]
 150   template <typename URBG>
 151   unsigned_type Generate(URBG& g,  // NOLINT(runtime/references)
 152                          unsigned_type R);
 153   param_type param_;
 154 };
 155
 156 // -----------------------------------------------------------------------------
 157 // Implementation details follow
 158 // -----------------------------------------------------------------------------
 159 template <typename CharT, typename Traits, typename IntType>
 160 std::basic_ostream<CharT, Traits>& operator<<(
 161     std::basic_ostream<CharT, Traits>& os,
 162     const uniform_int_distribution<IntType>& x) {
 163   using stream_type =
 164       typename random_internal::stream_format_type<IntType>::type;
 165   auto saver = random_internal::make_ostream_state_saver(os);
 166   os << static_cast<stream_type>(x.a()) << os.fill()
 167      << static_cast<stream_type>(x.b());
 168   return os;
 169 }
 170
 171 template <typename CharT, typename Traits, typename IntType>
 172 std::basic_istream<CharT, Traits>& operator>>(
 173     std::basic_istream<CharT, Traits>& is,
 174     uniform_int_distribution<IntType>& x) {
 175   using param_type = typename uniform_int_distribution<IntType>::param_type;
 176   using result_type = typename uniform_int_distribution<IntType>::result_type;
 177   using stream_type =
 178       typename random_internal::stream_format_type<IntType>::type;
 179
 180   stream_type a;
 181   stream_type b;
 182
 183   auto saver = random_internal::make_istream_state_saver(is);
 184   is >> a >> b;
 185   if (!is.fail()) {
 186     x.param(
 187         param_type(static_cast<result_type>(a), static_cast<result_type>(b)));
 188   }
 189   return is;
 190 }
 191
 192 template <typename IntType>
 193 template <typename URBG>
 194 typename random_internal::make_unsigned_bits<IntType>::type
 195 uniform_int_distribution<IntType>::Generate(
 196     URBG& g,  // NOLINT(runtime/references)
 197     typename random_internal::make_unsigned_bits<IntType>::type R) {
 198     random_internal::FastUniformBits<unsigned_type> fast_bits;
 199   unsigned_type bits = fast_bits(g);
 200   const unsigned_type Lim = R + 1;
 201   if ((R & Lim) == 0) {
 202     // If the interval's length is a power of two range, just take the low bits.
 203     return bits & R;
 204   }
 205
 206   // Generates a uniform variate on [0, Lim) using fixed-point multiplication.
 207   // The above fast-path guarantees that Lim is representable in unsigned_type.
 208   //
 209   // Algorithm adapted from
 210   // http://lemire.me/blog/2016/06/30/fast-random-shuffling/, with added
 211   // explanation.
 212   //
 213   // The algorithm creates a uniform variate `bits` in the interval [0, 2^N),
 214   // and treats it as the fractional part of a fixed-point real value in [0, 1),
 215   // multiplied by 2^N.  For example, 0.25 would be represented as 2^(N - 2),
 216   // because 2^N * 0.25 == 2^(N - 2).
 217   //
 218   // Next, `bits` and `Lim` are multiplied with a wide-multiply to bring the
 219   // value into the range [0, Lim).  The integral part (the high word of the
 220   // multiplication result) is then very nearly the desired result.  However,
 221   // this is not quite accurate; viewing the multiplication result as one
 222   // double-width integer, the resulting values for the sample are mapped as
 223   // follows:
 224   //
 225   // If the result lies in this interval:       Return this value:
 226   //        [0, 2^N)                                    0
 227   //        [2^N, 2 * 2^N)                              1
 228   //        ...                                         ...
 229   //        [K * 2^N, (K + 1) * 2^N)                    K
 230   //        ...                                         ...
 231   //        [(Lim - 1) * 2^N, Lim * 2^N)                Lim - 1
 232   //
 233   // While all of these intervals have the same size, the result of `bits * Lim`
 234   // must be a multiple of `Lim`, and not all of these intervals contain the
 235   // same number of multiples of `Lim`.  In particular, some contain
 236   // `F = floor(2^N / Lim)` and some contain `F + 1 = ceil(2^N / Lim)`.  This
 237   // difference produces a small nonuniformity, which is corrected by applying
 238   // rejection sampling to one of the values in the "larger intervals" (i.e.,
 239   // the intervals containing `F + 1` multiples of `Lim`.
 240   //
 241   // An interval contains `F + 1` multiples of `Lim` if and only if its smallest
 242   // value modulo 2^N is less than `2^N % Lim`.  The unique value satisfying
 243   // this property is used as the one for rejection.  That is, a value of
 244   // `bits * Lim` is rejected if `(bit * Lim) % 2^N < (2^N % Lim)`.
 245
 246   using helper = random_internal::wide_multiply<unsigned_type>;
 247   auto product = helper::multiply(bits, Lim);
 248
 249   // Two optimizations here:
 250   // * Rejection occurs with some probability less than 1/2, and for reasonable
 251   //   ranges considerably less (in particular, less than 1/(F+1)), so
 252   //   ABSL_PREDICT_FALSE is apt.
 253   // * `Lim` is an overestimate of `threshold`, and doesn't require a divide.
 254   if (ABSL_PREDICT_FALSE(helper::lo(product) < Lim)) {
 255     // This quantity is exactly equal to `2^N % Lim`, but does not require high
 256     // precision calculations: `2^N % Lim` is congruent to `(2^N - Lim) % Lim`.
 257     // Ideally this could be expressed simply as `-X` rather than `2^N - X`, but
 258     // for types smaller than int, this calculation is incorrect due to integer
 259     // promotion rules.
 260     const unsigned_type threshold =
 261         ((std::numeric_limits<unsigned_type>::max)() - Lim + 1) % Lim;
 262     while (helper::lo(product) < threshold) {
 263       bits = fast_bits(g);
 264       product = helper::multiply(bits, Lim);
 265     }
 266   }
 267
 268   return helper::hi(product);
 269 }
 270
 271 }  // namespace absl
 272
 273 #endif  // ABSL_RANDOM_UNIFORM_INT_DISTRIBUTION_H_