From 5aa5d282eac56a21e74611c1cdbaa97bb5db2dca Mon Sep 17 00:00:00 2001 From: Vincent Ambo Date: Tue, 8 Feb 2022 02:05:36 +0300 Subject: chore(3p/abseil_cpp): unvendor abseil_cpp we weren't actually using these sources anymore, okay? Change-Id: If701571d9716de308d3512e1eb22c35db0877a66 Reviewed-on: https://cl.tvl.fyi/c/depot/+/5248 Tested-by: BuildkiteCI Reviewed-by: grfn Autosubmit: tazjin --- .../absl/random/uniform_int_distribution.h | 275 --------------------- 1 file changed, 275 deletions(-) delete mode 100644 third_party/abseil_cpp/absl/random/uniform_int_distribution.h (limited to 'third_party/abseil_cpp/absl/random/uniform_int_distribution.h') diff --git a/third_party/abseil_cpp/absl/random/uniform_int_distribution.h b/third_party/abseil_cpp/absl/random/uniform_int_distribution.h deleted file mode 100644 index c1f54ccebce5..000000000000 --- a/third_party/abseil_cpp/absl/random/uniform_int_distribution.h +++ /dev/null @@ -1,275 +0,0 @@ -// 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 -#include -#include -#include - -#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 -// -// 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(1, 6)(gen); -// -template -class uniform_int_distribution { - private: - using unsigned_type = - typename random_internal::make_unsigned_bits::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::max)()) - : lo_(lo), - range_(static_cast(hi) - - static_cast(lo)) { - // [rand.dist.uni.int] precondition 2 - assert(lo <= hi); - } - - result_type a() const { return lo_; } - result_type b() const { - return static_cast(static_cast(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::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::max)()) - : param_(lo, hi) {} - - explicit uniform_int_distribution(const param_type& param) : param_(param) {} - - // uniform_int_distribution::reset() - // - // Resets the uniform int distribution. Note that this function has no effect - // because the distribution already produces independent values. - void reset() {} - - template - result_type operator()(URBG& gen) { // NOLINT(runtime/references) - return (*this)(gen, param()); - } - - template - 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 - unsigned_type Generate(URBG& g, // NOLINT(runtime/references) - unsigned_type R); - param_type param_; -}; - -// ----------------------------------------------------------------------------- -// Implementation details follow -// ----------------------------------------------------------------------------- -template -std::basic_ostream& operator<<( - std::basic_ostream& os, - const uniform_int_distribution& x) { - using stream_type = - typename random_internal::stream_format_type::type; - auto saver = random_internal::make_ostream_state_saver(os); - os << static_cast(x.a()) << os.fill() - << static_cast(x.b()); - return os; -} - -template -std::basic_istream& operator>>( - std::basic_istream& is, - uniform_int_distribution& x) { - using param_type = typename uniform_int_distribution::param_type; - using result_type = typename uniform_int_distribution::result_type; - using stream_type = - typename random_internal::stream_format_type::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(a), static_cast(b))); - } - return is; -} - -template -template -typename random_internal::make_unsigned_bits::type -uniform_int_distribution::Generate( - URBG& g, // NOLINT(runtime/references) - typename random_internal::make_unsigned_bits::type R) { - random_internal::FastUniformBits 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; - 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::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_ -- cgit 1.4.1