@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/random/exponential_distribution.h

@@ -1,166 +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.
-
-#ifndef ABSL_RANDOM_EXPONENTIAL_DISTRIBUTION_H_
-#define ABSL_RANDOM_EXPONENTIAL_DISTRIBUTION_H_
-
-#include <cassert>
-#include <cmath>
-#include <istream>
-#include <limits>
-#include <type_traits>
-
-#include "absl/base/config.h"
-#include "absl/meta/type_traits.h"
-#include "absl/random/internal/fast_uniform_bits.h"
-#include "absl/random/internal/generate_real.h"
-#include "absl/random/internal/iostream_state_saver.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-
-// absl::exponential_distribution:
-// Generates a number conforming to an exponential distribution and is
-// equivalent to the standard [rand.dist.pois.exp] distribution.
-template <typename RealType = double>
-class exponential_distribution {
- public:
-  using result_type = RealType;
-
-  class param_type {
-   public:
-    using distribution_type = exponential_distribution;
-
-    explicit param_type(result_type lambda = 1) : lambda_(lambda) {
-      assert(lambda > 0);
-      neg_inv_lambda_ = -result_type(1) / lambda_;
-    }
-
-    result_type lambda() const { return lambda_; }
-
-    friend bool operator==(const param_type& a, const param_type& b) {
-      return a.lambda_ == b.lambda_;
-    }
-
-    friend bool operator!=(const param_type& a, const param_type& b) {
-      return !(a == b);
-    }
-
-   private:
-    friend class exponential_distribution;
-
-    result_type lambda_;
-    result_type neg_inv_lambda_;
-
-    static_assert(
-        std::is_floating_point<RealType>::value,
-        "Class-template absl::exponential_distribution<> must be parameterized "
-        "using a floating-point type.");
-  };
-
-  exponential_distribution() : exponential_distribution(1) {}
-
-  explicit exponential_distribution(result_type lambda) : param_(lambda) {}
-
-  explicit exponential_distribution(const param_type& p) : param_(p) {}
-
-  void reset() {}
-
-  // Generating functions
-  template <typename URBG>
-  result_type operator()(URBG& g) {  // NOLINT(runtime/references)
-    return (*this)(g, param_);
-  }
-
-  template <typename URBG>
-  result_type operator()(URBG& g,  // NOLINT(runtime/references)
-                         const param_type& p);
-
-  param_type param() const { return param_; }
-  void param(const param_type& p) { param_ = p; }
-
-  result_type(min)() const { return 0; }
-  result_type(max)() const {
-    return std::numeric_limits<result_type>::infinity();
-  }
-
-  result_type lambda() const { return param_.lambda(); }
-
-  friend bool operator==(const exponential_distribution& a,
-                         const exponential_distribution& b) {
-    return a.param_ == b.param_;
-  }
-  friend bool operator!=(const exponential_distribution& a,
-                         const exponential_distribution& b) {
-    return a.param_ != b.param_;
-  }
-
- private:
-  param_type param_;
-  random_internal::FastUniformBits<uint64_t> fast_u64_;
-};
-
-// --------------------------------------------------------------------------
-// Implementation details follow
-// --------------------------------------------------------------------------
-
-template <typename RealType>
-template <typename URBG>
-typename exponential_distribution<RealType>::result_type
-exponential_distribution<RealType>::operator()(
-    URBG& g,  // NOLINT(runtime/references)
-    const param_type& p) {
-  using random_internal::GenerateNegativeTag;
-  using random_internal::GenerateRealFromBits;
-  using real_type =
-      absl::conditional_t<std::is_same<RealType, float>::value, float, double>;
-
-  const result_type u = GenerateRealFromBits<real_type, GenerateNegativeTag,
-                                             false>(fast_u64_(g));  // U(-1, 0)
-
-  // log1p(-x) is mathematically equivalent to log(1 - x) but has more
-  // accuracy for x near zero.
-  return p.neg_inv_lambda_ * std::log1p(u);
-}
-
-template <typename CharT, typename Traits, typename RealType>
-std::basic_ostream<CharT, Traits>& operator<<(
-    std::basic_ostream<CharT, Traits>& os,  // NOLINT(runtime/references)
-    const exponential_distribution<RealType>& x) {
-  auto saver = random_internal::make_ostream_state_saver(os);
-  os.precision(random_internal::stream_precision_helper<RealType>::kPrecision);
-  os << x.lambda();
-  return os;
-}
-
-template <typename CharT, typename Traits, typename RealType>
-std::basic_istream<CharT, Traits>& operator>>(
-    std::basic_istream<CharT, Traits>& is,    // NOLINT(runtime/references)
-    exponential_distribution<RealType>& x) {  // NOLINT(runtime/references)
-  using result_type = typename exponential_distribution<RealType>::result_type;
-  using param_type = typename exponential_distribution<RealType>::param_type;
-  result_type lambda;
-
-  auto saver = random_internal::make_istream_state_saver(is);
-  lambda = random_internal::read_floating_point<result_type>(is);
-  if (!is.fail()) {
-    x.param(param_type(lambda));
-  }
-  return is;
-}
-
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_RANDOM_EXPONENTIAL_DISTRIBUTION_H_

package/deps/abseil-cpp/absl/random/exponential_distribution_test.cc

@@ -1,426 +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.
-
-#include "absl/random/exponential_distribution.h"
-
-#include <algorithm>
-#include <cfloat>
-#include <cmath>
-#include <cstddef>
-#include <cstdint>
-#include <iterator>
-#include <limits>
-#include <random>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <vector>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/base/macros.h"
-#include "absl/log/log.h"
-#include "absl/numeric/internal/representation.h"
-#include "absl/random/internal/chi_square.h"
-#include "absl/random/internal/distribution_test_util.h"
-#include "absl/random/internal/pcg_engine.h"
-#include "absl/random/internal/sequence_urbg.h"
-#include "absl/random/random.h"
-#include "absl/strings/str_cat.h"
-#include "absl/strings/str_format.h"
-#include "absl/strings/str_replace.h"
-#include "absl/strings/strip.h"
-
-namespace {
-
-using absl::random_internal::kChiSquared;
-
-template <typename RealType>
-class ExponentialDistributionTypedTest : public ::testing::Test {};
-
-// double-double arithmetic is not supported well by either GCC or Clang; see
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99048,
-// https://bugs.llvm.org/show_bug.cgi?id=49131, and
-// https://bugs.llvm.org/show_bug.cgi?id=49132. Don't bother running these tests
-// with double doubles until compiler support is better.
-using RealTypes =
-    std::conditional<absl::numeric_internal::IsDoubleDouble(),
-                     ::testing::Types<float, double>,
-                     ::testing::Types<float, double, long double>>::type;
-TYPED_TEST_SUITE(ExponentialDistributionTypedTest, RealTypes);
-
-TYPED_TEST(ExponentialDistributionTypedTest, SerializeTest) {
-  using param_type =
-      typename absl::exponential_distribution<TypeParam>::param_type;
-
-  const TypeParam kParams[] = {
-      // Cases around 1.
-      1,                                           //
-      std::nextafter(TypeParam(1), TypeParam(0)),  // 1 - epsilon
-      std::nextafter(TypeParam(1), TypeParam(2)),  // 1 + epsilon
-      // Typical cases.
-      TypeParam(1e-8), TypeParam(1e-4), TypeParam(1), TypeParam(2),
-      TypeParam(1e4), TypeParam(1e8), TypeParam(1e20), TypeParam(2.5),
-      // Boundary cases.
-      std::numeric_limits<TypeParam>::max(),
-      std::numeric_limits<TypeParam>::epsilon(),
-      std::nextafter(std::numeric_limits<TypeParam>::min(),
-                     TypeParam(1)),           // min + epsilon
-      std::numeric_limits<TypeParam>::min(),  // smallest normal
-      // There are some errors dealing with denorms on apple platforms.
-      std::numeric_limits<TypeParam>::denorm_min(),  // smallest denorm
-      std::numeric_limits<TypeParam>::min() / 2,     // denorm
-      std::nextafter(std::numeric_limits<TypeParam>::min(),
-                     TypeParam(0)),  // denorm_max
-  };
-
-  constexpr int kCount = 1000;
-  absl::InsecureBitGen gen;
-
-  for (const TypeParam lambda : kParams) {
-    // Some values may be invalid; skip those.
-    if (!std::isfinite(lambda)) continue;
-    ABSL_ASSERT(lambda > 0);
-
-    const param_type param(lambda);
-
-    absl::exponential_distribution<TypeParam> before(lambda);
-    EXPECT_EQ(before.lambda(), param.lambda());
-
-    {
-      absl::exponential_distribution<TypeParam> via_param(param);
-      EXPECT_EQ(via_param, before);
-      EXPECT_EQ(via_param.param(), before.param());
-    }
-
-    // Smoke test.
-    auto sample_min = before.max();
-    auto sample_max = before.min();
-    for (int i = 0; i < kCount; i++) {
-      auto sample = before(gen);
-      EXPECT_GE(sample, before.min()) << before;
-      EXPECT_LE(sample, before.max()) << before;
-      if (sample > sample_max) sample_max = sample;
-      if (sample < sample_min) sample_min = sample;
-    }
-    if (!std::is_same<TypeParam, long double>::value) {
-      LOG(INFO) << "Range {" << lambda << "}: " << sample_min << ", "
-                << sample_max << ", lambda=" << lambda;
-    }
-
-    std::stringstream ss;
-    ss << before;
-
-    if (!std::isfinite(lambda)) {
-      // Streams do not deserialize inf/nan correctly.
-      continue;
-    }
-    // Validate stream serialization.
-    absl::exponential_distribution<TypeParam> after(34.56f);
-
-    EXPECT_NE(before.lambda(), after.lambda());
-    EXPECT_NE(before.param(), after.param());
-    EXPECT_NE(before, after);
-
-    ss >> after;
-
-    EXPECT_EQ(before.lambda(), after.lambda())  //
-        << ss.str() << " "                      //
-        << (ss.good() ? "good " : "")           //
-        << (ss.bad() ? "bad " : "")             //
-        << (ss.eof() ? "eof " : "")             //
-        << (ss.fail() ? "fail " : "");
-  }
-}
-
-// http://www.itl.nist.gov/div898/handbook/eda/section3/eda3667.htm
-
-class ExponentialModel {
- public:
-  explicit ExponentialModel(double lambda)
-      : lambda_(lambda), beta_(1.0 / lambda) {}
-
-  double lambda() const { return lambda_; }
-
-  double mean() const { return beta_; }
-  double variance() const { return beta_ * beta_; }
-  double stddev() const { return std::sqrt(variance()); }
-  double skew() const { return 2; }
-  double kurtosis() const { return 6.0; }
-
-  double CDF(double x) { return 1.0 - std::exp(-lambda_ * x); }
-
-  // The inverse CDF, or PercentPoint function of the distribution
-  double InverseCDF(double p) {
-    ABSL_ASSERT(p >= 0.0);
-    ABSL_ASSERT(p < 1.0);
-    return -beta_ * std::log(1.0 - p);
-  }
-
- private:
-  const double lambda_;
-  const double beta_;
-};
-
-struct Param {
-  double lambda;
-  double p_fail;
-  int trials;
-};
-
-class ExponentialDistributionTests : public testing::TestWithParam<Param>,
-                                     public ExponentialModel {
- public:
-  ExponentialDistributionTests() : ExponentialModel(GetParam().lambda) {}
-
-  // SingleZTest provides a basic z-squared test of the mean vs. expected
-  // mean for data generated by the poisson distribution.
-  template <typename D>
-  bool SingleZTest(const double p, const size_t samples);
-
-  // SingleChiSquaredTest provides a basic chi-squared test of the normal
-  // distribution.
-  template <typename D>
-  double SingleChiSquaredTest();
-
-  // We use a fixed bit generator for distribution accuracy tests.  This allows
-  // these tests to be deterministic, while still testing the qualify of the
-  // implementation.
-  absl::random_internal::pcg64_2018_engine rng_{0x2B7E151628AED2A6};
-};
-
-template <typename D>
-bool ExponentialDistributionTests::SingleZTest(const double p,
-                                               const size_t samples) {
-  D dis(lambda());
-
-  std::vector<double> data;
-  data.reserve(samples);
-  for (size_t i = 0; i < samples; i++) {
-    const double x = dis(rng_);
-    data.push_back(x);
-  }
-
-  const auto m = absl::random_internal::ComputeDistributionMoments(data);
-  const double max_err = absl::random_internal::MaxErrorTolerance(p);
-  const double z = absl::random_internal::ZScore(mean(), m);
-  const bool pass = absl::random_internal::Near("z", z, 0.0, max_err);
-
-  if (!pass) {
-    // clang-format off
-    LOG(INFO)
-        << "p=" << p << " max_err=" << max_err << "\n"
-           " lambda=" << lambda() << "\n"
-           " mean=" << m.mean << " vs. " << mean() << "\n"
-           " stddev=" << std::sqrt(m.variance) << " vs. " << stddev() << "\n"
-           " skewness=" << m.skewness << " vs. " << skew() << "\n"
-           " kurtosis=" << m.kurtosis << " vs. " << kurtosis() << "\n"
-           " z=" << z << " vs. 0";
-    // clang-format on
-  }
-  return pass;
-}
-
-template <typename D>
-double ExponentialDistributionTests::SingleChiSquaredTest() {
-  const size_t kSamples = 10000;
-  const int kBuckets = 50;
-
-  // The InverseCDF is the percent point function of the distribution, and can
-  // be used to assign buckets roughly uniformly.
-  std::vector<double> cutoffs;
-  const double kInc = 1.0 / static_cast<double>(kBuckets);
-  for (double p = kInc; p < 1.0; p += kInc) {
-    cutoffs.push_back(InverseCDF(p));
-  }
-  if (cutoffs.back() != std::numeric_limits<double>::infinity()) {
-    cutoffs.push_back(std::numeric_limits<double>::infinity());
-  }
-
-  D dis(lambda());
-
-  std::vector<int32_t> counts(cutoffs.size(), 0);
-  for (int j = 0; j < kSamples; j++) {
-    const double x = dis(rng_);
-    auto it = std::upper_bound(cutoffs.begin(), cutoffs.end(), x);
-    counts[std::distance(cutoffs.begin(), it)]++;
-  }
-
-  // Null-hypothesis is that the distribution is exponentially distributed
-  // with the provided lambda (not estimated from the data).
-  const int dof = static_cast<int>(counts.size()) - 1;
-
-  // Our threshold for logging is 1-in-50.
-  const double threshold = absl::random_internal::ChiSquareValue(dof, 0.98);
-
-  const double expected =
-      static_cast<double>(kSamples) / static_cast<double>(counts.size());
-
-  double chi_square = absl::random_internal::ChiSquareWithExpected(
-      std::begin(counts), std::end(counts), expected);
-  double p = absl::random_internal::ChiSquarePValue(chi_square, dof);
-
-  if (chi_square > threshold) {
-    for (size_t i = 0; i < cutoffs.size(); i++) {
-      LOG(INFO) << i << " : (" << cutoffs[i] << ") = " << counts[i];
-    }
-
-    // clang-format off
-    LOG(INFO) << "lambda " << lambda() << "\n"
-                 " expected " << expected << "\n"
-              << kChiSquared << " " << chi_square << " (" << p << ")\n"
-              << kChiSquared << " @ 0.98 = " << threshold;
-    // clang-format on
-  }
-  return p;
-}
-
-TEST_P(ExponentialDistributionTests, ZTest) {
-  const size_t kSamples = 10000;
-  const auto& param = GetParam();
-  const int expected_failures =
-      std::max(1, static_cast<int>(std::ceil(param.trials * param.p_fail)));
-  const double p = absl::random_internal::RequiredSuccessProbability(
-      param.p_fail, param.trials);
-
-  int failures = 0;
-  for (int i = 0; i < param.trials; i++) {
-    failures += SingleZTest<absl::exponential_distribution<double>>(p, kSamples)
-                    ? 0
-                    : 1;
-  }
-  EXPECT_LE(failures, expected_failures);
-}
-
-TEST_P(ExponentialDistributionTests, ChiSquaredTest) {
-  const int kTrials = 20;
-  int failures = 0;
-
-  for (int i = 0; i < kTrials; i++) {
-    double p_value =
-        SingleChiSquaredTest<absl::exponential_distribution<double>>();
-    if (p_value < 0.005) {  // 1/200
-      failures++;
-    }
-  }
-
-  // There is a 0.10% chance of producing at least one failure, so raise the
-  // failure threshold high enough to allow for a flake rate < 10,000.
-  EXPECT_LE(failures, 4);
-}
-
-std::vector<Param> GenParams() {
-  return {
-      Param{1.0, 0.02, 100},
-      Param{2.5, 0.02, 100},
-      Param{10, 0.02, 100},
-      // large
-      Param{1e4, 0.02, 100},
-      Param{1e9, 0.02, 100},
-      // small
-      Param{0.1, 0.02, 100},
-      Param{1e-3, 0.02, 100},
-      Param{1e-5, 0.02, 100},
-  };
-}
-
-std::string ParamName(const ::testing::TestParamInfo<Param>& info) {
-  const auto& p = info.param;
-  std::string name = absl::StrCat("lambda_", absl::SixDigits(p.lambda));
-  return absl::StrReplaceAll(name, {{"+", "_"}, {"-", "_"}, {".", "_"}});
-}
-
-INSTANTIATE_TEST_SUITE_P(All, ExponentialDistributionTests,
-                         ::testing::ValuesIn(GenParams()), ParamName);
-
-// NOTE: absl::exponential_distribution is not guaranteed to be stable.
-TEST(ExponentialDistributionTest, StabilityTest) {
-  // absl::exponential_distribution stability relies on std::log1p and
-  // absl::uniform_real_distribution.
-  absl::random_internal::sequence_urbg urbg(
-      {0x0003eb76f6f7f755ull, 0xFFCEA50FDB2F953Bull, 0xC332DDEFBE6C5AA5ull,
-       0x6558218568AB9702ull, 0x2AEF7DAD5B6E2F84ull, 0x1521B62829076170ull,
-       0xECDD4775619F1510ull, 0x13CCA830EB61BD96ull, 0x0334FE1EAA0363CFull,
-       0xB5735C904C70A239ull, 0xD59E9E0BCBAADE14ull, 0xEECC86BC60622CA7ull});
-
-  std::vector<int> output(14);
-
-  {
-    absl::exponential_distribution<double> dist;
-    std::generate(std::begin(output), std::end(output),
-                  [&] { return static_cast<int>(10000.0 * dist(urbg)); });
-
-    EXPECT_EQ(14, urbg.invocations());
-    EXPECT_THAT(output,
-                testing::ElementsAre(0, 71913, 14375, 5039, 1835, 861, 25936,
-                                     804, 126, 12337, 17984, 27002, 0, 71913));
-  }
-
-  urbg.reset();
-  {
-    absl::exponential_distribution<float> dist;
-    std::generate(std::begin(output), std::end(output),
-                  [&] { return static_cast<int>(10000.0f * dist(urbg)); });
-
-    EXPECT_EQ(14, urbg.invocations());
-    EXPECT_THAT(output,
-                testing::ElementsAre(0, 71913, 14375, 5039, 1835, 861, 25936,
-                                     804, 126, 12337, 17984, 27002, 0, 71913));
-  }
-}
-
-TEST(ExponentialDistributionTest, AlgorithmBounds) {
-  // Relies on absl::uniform_real_distribution, so some of these comments
-  // reference that.
-
-#if (defined(__i386__) || defined(_M_IX86)) && FLT_EVAL_METHOD != 0
-  // We're using an x87-compatible FPU, and intermediate operations can be
-  // performed with 80-bit floats. This produces slightly different results from
-  // what we expect below.
-  GTEST_SKIP()
-      << "Skipping the test because we detected x87 floating-point semantics";
-#endif
-
-  absl::exponential_distribution<double> dist;
-
-  {
-    // This returns the smallest value >0 from absl::uniform_real_distribution.
-    absl::random_internal::sequence_urbg urbg({0x0000000000000001ull});
-    double a = dist(urbg);
-    EXPECT_EQ(a, 5.42101086242752217004e-20);
-  }
-
-  {
-    // This returns a value very near 0.5 from absl::uniform_real_distribution.
-    absl::random_internal::sequence_urbg urbg({0x7fffffffffffffefull});
-    double a = dist(urbg);
-    EXPECT_EQ(a, 0.693147180559945175204);
-  }
-
-  {
-    // This returns the largest value <1 from absl::uniform_real_distribution.
-    // WolframAlpha: ~39.1439465808987766283058547296341915292187253
-    absl::random_internal::sequence_urbg urbg({0xFFFFFFFFFFFFFFeFull});
-    double a = dist(urbg);
-    EXPECT_EQ(a, 36.7368005696771007251);
-  }
-  {
-    // This *ALSO* returns the largest value <1.
-    absl::random_internal::sequence_urbg urbg({0xFFFFFFFFFFFFFFFFull});
-    double a = dist(urbg);
-    EXPECT_EQ(a, 36.7368005696771007251);
-  }
-}
-
-}  // namespace

package/deps/abseil-cpp/absl/random/gaussian_distribution.cc

@@ -1,104 +0,0 @@
-// BEGIN GENERATED CODE; DO NOT EDIT
-// clang-format off
-
-#include "absl/random/gaussian_distribution.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-const gaussian_distribution_base::Tables
-    gaussian_distribution_base::zg_ = {
-    {3.7130862467425505, 3.442619855899000214, 3.223084984581141565,
-     3.083228858216868318, 2.978696252647779819, 2.894344007021528942,
-     2.82312535054891045, 2.761169372387176857, 2.706113573121819549,
-     2.656406411261359679, 2.610972248431847387, 2.56903362592493778,
-     2.530009672388827457, 2.493454522095372106, 2.459018177411830486,
-     2.426420645533749809, 2.395434278011062457, 2.365871370117638595,
-     2.337575241339236776, 2.310413683698762988, 2.284274059677471769,
-     2.25905957386919809, 2.234686395590979036, 2.21108140887870297,
-     2.188180432076048731, 2.165926793748921497, 2.144270182360394905,
-     2.123165708673976138, 2.102573135189237608, 2.082456237992015957,
-     2.062782274508307978, 2.043521536655067194, 2.02464697337738464,
-     2.006133869963471206, 1.987959574127619033, 1.970103260854325633,
-     1.952545729553555764, 1.935269228296621957, 1.918257300864508963,
-     1.901494653105150423, 1.884967035707758143, 1.868661140994487768,
-     1.852564511728090002, 1.836665460258444904, 1.820952996596124418,
-     1.805416764219227366, 1.790046982599857506, 1.77483439558606837,
-     1.759770224899592339, 1.744846128113799244, 1.730054160563729182,
-     1.71538674071366648, 1.700836618569915748, 1.686396846779167014,
-     1.6720607540975998, 1.657821920954023254, 1.643674156862867441,
-     1.629611479470633562, 1.615628095043159629, 1.601718380221376581,
-     1.587876864890574558, 1.574098216022999264, 1.560377222366167382,
-     1.546708779859908844, 1.533087877674041755, 1.519509584765938559,
-     1.505969036863201937, 1.492461423781352714, 1.478981976989922842,
-     1.465525957342709296, 1.452088642889222792, 1.438665316684561546,
-     1.425251254514058319, 1.411841712447055919, 1.398431914131003539,
-     1.385017037732650058, 1.371592202427340812, 1.358152454330141534,
-     1.34469275175354519, 1.331207949665625279, 1.317692783209412299,
-     1.304141850128615054, 1.290549591926194894, 1.27691027356015363,
-     1.263217961454619287, 1.249466499573066436, 1.23564948326336066,
-     1.221760230539994385, 1.207791750415947662, 1.193736707833126465,
-     1.17958738466398616, 1.165335636164750222, 1.150972842148865416,
-     1.136489852013158774, 1.121876922582540237, 1.107123647534034028,
-     1.092218876907275371, 1.077150624892893482, 1.061905963694822042,
-     1.046470900764042922, 1.030830236068192907, 1.014967395251327842,
-     0.9988642334929808131, 0.9825008035154263464, 0.9658550794011470098,
-     0.9489026255113034436, 0.9316161966151479401, 0.9139652510230292792,
-     0.8959153525809346874, 0.8774274291129204872, 0.8584568431938099931,
-     0.8389522142975741614, 0.8188539067003538507, 0.7980920606440534693,
-     0.7765839878947563557, 0.7542306644540520688, 0.7309119106424850631,
-     0.7064796113354325779, 0.6807479186691505202, 0.6534786387399710295,
-     0.6243585973360461505, 0.5929629424714434327, 0.5586921784081798625,
-     0.5206560387620546848, 0.4774378372966830431, 0.4265479863554152429,
-     0.3628714310970211909, 0.2723208648139477384, 0},
-    {0.001014352564120377413, 0.002669629083880922793, 0.005548995220771345792,
-     0.008624484412859888607, 0.01183947865788486861, 0.01516729801054656976,
-     0.01859210273701129151, 0.02210330461592709475, 0.02569329193593428151,
-     0.02935631744000685023, 0.03308788614622575758, 0.03688438878665621645,
-     0.04074286807444417458, 0.04466086220049143157, 0.04863629585986780496,
-     0.05266740190305100461, 0.05675266348104984759, 0.06089077034804041277,
-     0.06508058521306804567, 0.06932111739357792179, 0.07361150188411341722,
-     0.07795098251397346301, 0.08233889824223575293, 0.08677467189478028919,
-     0.09125780082683036809, 0.095787849121731522, 0.1003644410286559929,
-     0.1049872554094214289, 0.1096560210148404546, 0.1143705124488661323,
-     0.1191305467076509556, 0.1239359802028679736, 0.1287867061959434012,
-     0.1336826525834396151, 0.1386237799845948804, 0.1436100800906280339,
-     0.1486415742423425057, 0.1537183122081819397, 0.1588403711394795748,
-     0.1640078546834206341, 0.1692208922373653057, 0.1744796383307898324,
-     0.1797842721232958407, 0.1851349970089926078, 0.1905320403191375633,
-     0.1959756531162781534, 0.2014661100743140865, 0.2070037094399269362,
-     0.2125887730717307134, 0.2182216465543058426, 0.2239026993850088965,
-     0.229632325232116602, 0.2354109422634795556, 0.2412389935454402889,
-     0.2471169475123218551, 0.2530452985073261551, 0.2590245673962052742,
-     0.2650553022555897087, 0.271138079138385224, 0.2772735029191887857,
-     0.2834622082232336471, 0.2897048604429605656, 0.2960021568469337061,
-     0.3023548277864842593, 0.3087636380061818397, 0.3152293880650116065,
-     0.3217529158759855901, 0.3283350983728509642, 0.3349768533135899506,
-     0.3416791412315512977, 0.3484429675463274756, 0.355269384847918035,
-     0.3621594953693184626, 0.3691144536644731522, 0.376135469510563536,
-     0.3832238110559021416, 0.3903808082373155797, 0.3976078564938743676,
-     0.404906420807223999, 0.4122780401026620578, 0.4197243320495753771,
-     0.4272469983049970721, 0.4348478302499918513, 0.4425287152754694975,
-     0.4502916436820402768, 0.458138716267873114, 0.4660721526894572309,
-     0.4740943006930180559, 0.4822076463294863724, 0.4904148252838453348,
-     0.4987186354709807201, 0.5071220510755701794, 0.5156282382440030565,
-     0.5242405726729852944, 0.5329626593838373561, 0.5417983550254266145,
-     0.5507517931146057588, 0.5598274127040882009, 0.5690299910679523787,
-     0.5783646811197646898, 0.5878370544347081283, 0.5974531509445183408,
-     0.6072195366251219584, 0.6171433708188825973, 0.6272324852499290282,
-     0.6374954773350440806, 0.6479418211102242475, 0.6585820000500898219,
-     0.6694276673488921414, 0.6804918409973358395, 0.6917891434366769676,
-     0.7033360990161600101, 0.7151515074105005976, 0.7272569183441868201,
-     0.7396772436726493094, 0.7524415591746134169, 0.7655841738977066102,
-     0.7791460859296898134, 0.7931770117713072832, 0.8077382946829627652,
-     0.8229072113814113187, 0.8387836052959920519, 0.8555006078694531446,
-     0.873243048910072206, 0.8922816507840289901, 0.9130436479717434217,
-     0.9362826816850632339, 0.9635996931270905952, 1}};
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-// clang-format on
-// END GENERATED CODE