@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/random/internal/fast_uniform_bits_test.cc

@@ -1,336 +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/internal/fast_uniform_bits.h"
-
-#include <random>
-
-#include "gtest/gtest.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-namespace {
-
-template <typename IntType>
-class FastUniformBitsTypedTest : public ::testing::Test {};
-
-using IntTypes = ::testing::Types<uint8_t, uint16_t, uint32_t, uint64_t>;
-
-TYPED_TEST_SUITE(FastUniformBitsTypedTest, IntTypes);
-
-TYPED_TEST(FastUniformBitsTypedTest, BasicTest) {
-  using Limits = std::numeric_limits<TypeParam>;
-  using FastBits = FastUniformBits<TypeParam>;
-
-  EXPECT_EQ(0, (FastBits::min)());
-  EXPECT_EQ((Limits::max)(), (FastBits::max)());
-
-  constexpr int kIters = 10000;
-  std::random_device rd;
-  std::mt19937 gen(rd());
-  FastBits fast;
-  for (int i = 0; i < kIters; i++) {
-    const auto v = fast(gen);
-    EXPECT_LE(v, (FastBits::max)());
-    EXPECT_GE(v, (FastBits::min)());
-  }
-}
-
-template <typename UIntType, UIntType Lo, UIntType Hi, UIntType Val = Lo>
-struct FakeUrbg {
-  using result_type = UIntType;
-
-  FakeUrbg() = default;
-  explicit FakeUrbg(bool r) : reject(r) {}
-
-  static constexpr result_type(max)() { return Hi; }
-  static constexpr result_type(min)() { return Lo; }
-  result_type operator()() {
-    // when reject is set, return Hi half the time.
-    return ((++calls % 2) == 1 && reject) ? Hi : Val;
-  }
-
-  bool reject = false;
-  size_t calls = 0;
-};
-
-TEST(FastUniformBitsTest, IsPowerOfTwoOrZero) {
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint8_t{0}));
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint8_t{1}));
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint8_t{2}));
-  EXPECT_FALSE(IsPowerOfTwoOrZero(uint8_t{3}));
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint8_t{4}));
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint8_t{16}));
-  EXPECT_FALSE(IsPowerOfTwoOrZero(uint8_t{17}));
-  EXPECT_FALSE(IsPowerOfTwoOrZero((std::numeric_limits<uint8_t>::max)()));
-
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint16_t{0}));
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint16_t{1}));
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint16_t{2}));
-  EXPECT_FALSE(IsPowerOfTwoOrZero(uint16_t{3}));
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint16_t{4}));
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint16_t{16}));
-  EXPECT_FALSE(IsPowerOfTwoOrZero(uint16_t{17}));
-  EXPECT_FALSE(IsPowerOfTwoOrZero((std::numeric_limits<uint16_t>::max)()));
-
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint32_t{0}));
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint32_t{1}));
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint32_t{2}));
-  EXPECT_FALSE(IsPowerOfTwoOrZero(uint32_t{3}));
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint32_t{32}));
-  EXPECT_FALSE(IsPowerOfTwoOrZero(uint32_t{17}));
-  EXPECT_FALSE(IsPowerOfTwoOrZero((std::numeric_limits<uint32_t>::max)()));
-
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint64_t{0}));
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint64_t{1}));
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint64_t{2}));
-  EXPECT_FALSE(IsPowerOfTwoOrZero(uint64_t{3}));
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint64_t{4}));
-  EXPECT_TRUE(IsPowerOfTwoOrZero(uint64_t{64}));
-  EXPECT_FALSE(IsPowerOfTwoOrZero(uint64_t{17}));
-  EXPECT_FALSE(IsPowerOfTwoOrZero((std::numeric_limits<uint64_t>::max)()));
-}
-
-TEST(FastUniformBitsTest, IntegerLog2) {
-  EXPECT_EQ(0, IntegerLog2(uint16_t{0}));
-  EXPECT_EQ(0, IntegerLog2(uint16_t{1}));
-  EXPECT_EQ(1, IntegerLog2(uint16_t{2}));
-  EXPECT_EQ(1, IntegerLog2(uint16_t{3}));
-  EXPECT_EQ(2, IntegerLog2(uint16_t{4}));
-  EXPECT_EQ(2, IntegerLog2(uint16_t{5}));
-  EXPECT_EQ(2, IntegerLog2(uint16_t{7}));
-  EXPECT_EQ(3, IntegerLog2(uint16_t{8}));
-  EXPECT_EQ(63, IntegerLog2((std::numeric_limits<uint64_t>::max)()));
-}
-
-TEST(FastUniformBitsTest, RangeSize) {
-  EXPECT_EQ(2, (RangeSize<FakeUrbg<uint8_t, 0, 1>>()));
-  EXPECT_EQ(3, (RangeSize<FakeUrbg<uint8_t, 0, 2>>()));
-  EXPECT_EQ(4, (RangeSize<FakeUrbg<uint8_t, 0, 3>>()));
-  //  EXPECT_EQ(0, (RangeSize<FakeUrbg<uint8_t, 2, 2>>()));
-  EXPECT_EQ(4, (RangeSize<FakeUrbg<uint8_t, 2, 5>>()));
-  EXPECT_EQ(5, (RangeSize<FakeUrbg<uint8_t, 2, 6>>()));
-  EXPECT_EQ(9, (RangeSize<FakeUrbg<uint8_t, 2, 10>>()));
-  EXPECT_EQ(
-      0, (RangeSize<
-             FakeUrbg<uint8_t, 0, (std::numeric_limits<uint8_t>::max)()>>()));
-
-  EXPECT_EQ(4, (RangeSize<FakeUrbg<uint16_t, 0, 3>>()));
-  EXPECT_EQ(4, (RangeSize<FakeUrbg<uint16_t, 2, 5>>()));
-  EXPECT_EQ(5, (RangeSize<FakeUrbg<uint16_t, 2, 6>>()));
-  EXPECT_EQ(18, (RangeSize<FakeUrbg<uint16_t, 1000, 1017>>()));
-  EXPECT_EQ(
-      0, (RangeSize<
-             FakeUrbg<uint16_t, 0, (std::numeric_limits<uint16_t>::max)()>>()));
-
-  EXPECT_EQ(4, (RangeSize<FakeUrbg<uint32_t, 0, 3>>()));
-  EXPECT_EQ(4, (RangeSize<FakeUrbg<uint32_t, 2, 5>>()));
-  EXPECT_EQ(5, (RangeSize<FakeUrbg<uint32_t, 2, 6>>()));
-  EXPECT_EQ(18, (RangeSize<FakeUrbg<uint32_t, 1000, 1017>>()));
-  EXPECT_EQ(0, (RangeSize<FakeUrbg<uint32_t, 0, 0xffffffff>>()));
-  EXPECT_EQ(0xffffffff, (RangeSize<FakeUrbg<uint32_t, 1, 0xffffffff>>()));
-  EXPECT_EQ(0xfffffffe, (RangeSize<FakeUrbg<uint32_t, 1, 0xfffffffe>>()));
-  EXPECT_EQ(0xfffffffd, (RangeSize<FakeUrbg<uint32_t, 2, 0xfffffffe>>()));
-  EXPECT_EQ(
-      0, (RangeSize<
-             FakeUrbg<uint32_t, 0, (std::numeric_limits<uint32_t>::max)()>>()));
-
-  EXPECT_EQ(4, (RangeSize<FakeUrbg<uint64_t, 0, 3>>()));
-  EXPECT_EQ(4, (RangeSize<FakeUrbg<uint64_t, 2, 5>>()));
-  EXPECT_EQ(5, (RangeSize<FakeUrbg<uint64_t, 2, 6>>()));
-  EXPECT_EQ(18, (RangeSize<FakeUrbg<uint64_t, 1000, 1017>>()));
-  EXPECT_EQ(0x100000000, (RangeSize<FakeUrbg<uint64_t, 0, 0xffffffff>>()));
-  EXPECT_EQ(0xffffffff, (RangeSize<FakeUrbg<uint64_t, 1, 0xffffffff>>()));
-  EXPECT_EQ(0xfffffffe, (RangeSize<FakeUrbg<uint64_t, 1, 0xfffffffe>>()));
-  EXPECT_EQ(0xfffffffd, (RangeSize<FakeUrbg<uint64_t, 2, 0xfffffffe>>()));
-  EXPECT_EQ(0, (RangeSize<FakeUrbg<uint64_t, 0, 0xffffffffffffffff>>()));
-  EXPECT_EQ(0xffffffffffffffff,
-            (RangeSize<FakeUrbg<uint64_t, 1, 0xffffffffffffffff>>()));
-  EXPECT_EQ(0xfffffffffffffffe,
-            (RangeSize<FakeUrbg<uint64_t, 1, 0xfffffffffffffffe>>()));
-  EXPECT_EQ(0xfffffffffffffffd,
-            (RangeSize<FakeUrbg<uint64_t, 2, 0xfffffffffffffffe>>()));
-  EXPECT_EQ(
-      0, (RangeSize<
-             FakeUrbg<uint64_t, 0, (std::numeric_limits<uint64_t>::max)()>>()));
-}
-
-// The constants need to be chosen so that an infinite rejection loop doesn't
-// happen...
-using Urng1_5bit = FakeUrbg<uint8_t, 0, 2, 0>;  // ~1.5 bits (range 3)
-using Urng4bits = FakeUrbg<uint8_t, 1, 0x10, 2>;
-using Urng22bits = FakeUrbg<uint32_t, 0, 0x3fffff, 0x301020>;
-using Urng31bits = FakeUrbg<uint32_t, 1, 0xfffffffe, 0x60070f03>;  // ~31.9 bits
-using Urng32bits = FakeUrbg<uint32_t, 0, 0xffffffff, 0x74010f01>;
-using Urng33bits =
-    FakeUrbg<uint64_t, 1, 0x1ffffffff, 0x013301033>;  // ~32.9 bits
-using Urng63bits = FakeUrbg<uint64_t, 1, 0xfffffffffffffffe,
-                            0xfedcba9012345678>;  // ~63.9 bits
-using Urng64bits =
-    FakeUrbg<uint64_t, 0, 0xffffffffffffffff, 0x123456780fedcba9>;
-
-TEST(FastUniformBitsTest, OutputsUpTo32Bits) {
-  // Tests that how values are composed; the single-bit deltas should be spread
-  // across each invocation.
-  Urng1_5bit urng1_5;
-  Urng4bits urng4;
-  Urng22bits urng22;
-  Urng31bits urng31;
-  Urng32bits urng32;
-  Urng33bits urng33;
-  Urng63bits urng63;
-  Urng64bits urng64;
-
-  // 8-bit types
-  {
-    FastUniformBits<uint8_t> fast8;
-    EXPECT_EQ(0x0, fast8(urng1_5));
-    EXPECT_EQ(0x11, fast8(urng4));
-    EXPECT_EQ(0x20, fast8(urng22));
-    EXPECT_EQ(0x2, fast8(urng31));
-    EXPECT_EQ(0x1, fast8(urng32));
-    EXPECT_EQ(0x32, fast8(urng33));
-    EXPECT_EQ(0x77, fast8(urng63));
-    EXPECT_EQ(0xa9, fast8(urng64));
-  }
-
-  // 16-bit types
-  {
-    FastUniformBits<uint16_t> fast16;
-    EXPECT_EQ(0x0, fast16(urng1_5));
-    EXPECT_EQ(0x1111, fast16(urng4));
-    EXPECT_EQ(0x1020, fast16(urng22));
-    EXPECT_EQ(0x0f02, fast16(urng31));
-    EXPECT_EQ(0x0f01, fast16(urng32));
-    EXPECT_EQ(0x1032, fast16(urng33));
-    EXPECT_EQ(0x5677, fast16(urng63));
-    EXPECT_EQ(0xcba9, fast16(urng64));
-  }
-
-  // 32-bit types
-  {
-    FastUniformBits<uint32_t> fast32;
-    EXPECT_EQ(0x0, fast32(urng1_5));
-    EXPECT_EQ(0x11111111, fast32(urng4));
-    EXPECT_EQ(0x08301020, fast32(urng22));
-    EXPECT_EQ(0x0f020f02, fast32(urng31));
-    EXPECT_EQ(0x74010f01, fast32(urng32));
-    EXPECT_EQ(0x13301032, fast32(urng33));
-    EXPECT_EQ(0x12345677, fast32(urng63));
-    EXPECT_EQ(0x0fedcba9, fast32(urng64));
-  }
-}
-
-TEST(FastUniformBitsTest, Outputs64Bits) {
-  // Tests that how values are composed; the single-bit deltas should be spread
-  // across each invocation.
-  FastUniformBits<uint64_t> fast64;
-
-  {
-    FakeUrbg<uint8_t, 0, 1, 0> urng0;
-    FakeUrbg<uint8_t, 0, 1, 1> urng1;
-    Urng4bits urng4;
-    Urng22bits urng22;
-    Urng31bits urng31;
-    Urng32bits urng32;
-    Urng33bits urng33;
-    Urng63bits urng63;
-    Urng64bits urng64;
-
-    // somewhat degenerate cases only create a single bit.
-    EXPECT_EQ(0x0, fast64(urng0));
-    EXPECT_EQ(64, urng0.calls);
-    EXPECT_EQ(0xffffffffffffffff, fast64(urng1));
-    EXPECT_EQ(64, urng1.calls);
-
-    // less degenerate cases.
-    EXPECT_EQ(0x1111111111111111, fast64(urng4));
-    EXPECT_EQ(16, urng4.calls);
-    EXPECT_EQ(0x01020c0408301020, fast64(urng22));
-    EXPECT_EQ(3, urng22.calls);
-    EXPECT_EQ(0x387811c3c0870f02, fast64(urng31));
-    EXPECT_EQ(3, urng31.calls);
-    EXPECT_EQ(0x74010f0174010f01, fast64(urng32));
-    EXPECT_EQ(2, urng32.calls);
-    EXPECT_EQ(0x808194040cb01032, fast64(urng33));
-    EXPECT_EQ(3, urng33.calls);
-    EXPECT_EQ(0x1234567712345677, fast64(urng63));
-    EXPECT_EQ(2, urng63.calls);
-    EXPECT_EQ(0x123456780fedcba9, fast64(urng64));
-    EXPECT_EQ(1, urng64.calls);
-  }
-
-  // The 1.5 bit case is somewhat interesting in that the algorithm refinement
-  // causes one extra small sample. Comments here reference the names used in
-  // [rand.adapt.ibits] that correspond to this case.
-  {
-    Urng1_5bit urng1_5;
-
-    // w = 64
-    // R = 3
-    // m = 1
-    // n' = 64
-    // w0' = 1
-    // y0' = 2
-    // n = (1 <= 0) > 64 : 65 = 65
-    // n0 = 65 - (64%65) = 1
-    // n1 = 64
-    // w0 = 0
-    // y0 = 3
-    // w1 = 1
-    // y1 = 2
-    EXPECT_EQ(0x0, fast64(urng1_5));
-    EXPECT_EQ(65, urng1_5.calls);
-  }
-
-  // Validate rejections for non-power-of-2 cases.
-  {
-    Urng1_5bit urng1_5(true);
-    Urng31bits urng31(true);
-    Urng33bits urng33(true);
-    Urng63bits urng63(true);
-
-    // For 1.5 bits, there would be 1+2*64, except the first
-    // value was accepted and shifted off the end.
-    EXPECT_EQ(0, fast64(urng1_5));
-    EXPECT_EQ(128, urng1_5.calls);
-    EXPECT_EQ(0x387811c3c0870f02, fast64(urng31));
-    EXPECT_EQ(6, urng31.calls);
-    EXPECT_EQ(0x808194040cb01032, fast64(urng33));
-    EXPECT_EQ(6, urng33.calls);
-    EXPECT_EQ(0x1234567712345677, fast64(urng63));
-    EXPECT_EQ(4, urng63.calls);
-  }
-}
-
-TEST(FastUniformBitsTest, URBG32bitRegression) {
-  // Validate with deterministic 32-bit std::minstd_rand
-  // to ensure that operator() performs as expected.
-
-  EXPECT_EQ(2147483646, RangeSize<std::minstd_rand>());
-  EXPECT_EQ(30, IntegerLog2(RangeSize<std::minstd_rand>()));
-
-  std::minstd_rand gen(1);
-  FastUniformBits<uint64_t> fast64;
-
-  EXPECT_EQ(0x05e47095f8791f45, fast64(gen));
-  EXPECT_EQ(0x028be17e3c07c122, fast64(gen));
-  EXPECT_EQ(0x55d2847c1626e8c2, fast64(gen));
-}
-
-}  // namespace
-}  // namespace random_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

package/deps/abseil-cpp/absl/random/internal/fastmath.h

@@ -1,57 +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_INTERNAL_FASTMATH_H_
-#define ABSL_RANDOM_INTERNAL_FASTMATH_H_
-
-// This file contains fast math functions (bitwise ops as well as some others)
-// which are implementation details of various absl random number distributions.
-
-#include <cassert>
-#include <cmath>
-#include <cstdint>
-
-#include "absl/numeric/bits.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-
-// Compute log2(n) using integer operations.
-// While std::log2 is more accurate than std::log(n) / std::log(2), for
-// very large numbers--those close to std::numeric_limits<uint64_t>::max() - 2,
-// for instance--std::log2 rounds up rather than down, which introduces
-// definite skew in the results.
-inline int IntLog2Floor(uint64_t n) {
-  return (n <= 1) ? 0 : (63 - countl_zero(n));
-}
-inline int IntLog2Ceil(uint64_t n) {
-  return (n <= 1) ? 0 : (64 - countl_zero(n - 1));
-}
-
-inline double StirlingLogFactorial(double n) {
-  assert(n >= 1);
-  // Using Stirling's approximation.
-  constexpr double kLog2PI = 1.83787706640934548356;
-  const double logn = std::log(n);
-  const double ninv = 1.0 / static_cast<double>(n);
-  return n * logn - n + 0.5 * (kLog2PI + logn) + (1.0 / 12.0) * ninv -
-         (1.0 / 360.0) * ninv * ninv * ninv;
-}
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_RANDOM_INTERNAL_FASTMATH_H_

package/deps/abseil-cpp/absl/random/internal/fastmath_test.cc

@@ -1,95 +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/internal/fastmath.h"
-
-#include "gtest/gtest.h"
-
-#if defined(__EMSCRIPTEN__)
-// Emscripten has a less accurate implementation of std::log2 than most of
-// the other platforms. For some values which should have integral results,
-// sometimes Emscripten returns slightly larger values.
-#define ABSL_RANDOM_INACCURATE_LOG2
-#endif
-
-namespace {
-
-TEST(FastMathTest, IntLog2FloorTest) {
-  using absl::random_internal::IntLog2Floor;
-  constexpr uint64_t kZero = 0;
-  EXPECT_EQ(0, IntLog2Floor(0));  // boundary. return 0.
-  EXPECT_EQ(0, IntLog2Floor(1));
-  EXPECT_EQ(1, IntLog2Floor(2));
-  EXPECT_EQ(63, IntLog2Floor(~kZero));
-
-  // A boundary case: Converting 0xffffffffffffffff requires > 53
-  // bits of precision, so the conversion to double rounds up,
-  // and the result of std::log2(x) > IntLog2Floor(x).
-  EXPECT_LT(IntLog2Floor(~kZero), static_cast<int>(std::log2(~kZero)));
-
-  for (int i = 0; i < 64; i++) {
-    const uint64_t i_pow_2 = static_cast<uint64_t>(1) << i;
-    EXPECT_EQ(i, IntLog2Floor(i_pow_2));
-    EXPECT_EQ(i, static_cast<int>(std::log2(i_pow_2)));
-
-    uint64_t y = i_pow_2;
-    for (int j = i - 1; j > 0; --j) {
-      y = y | (i_pow_2 >> j);
-      EXPECT_EQ(i, IntLog2Floor(y));
-    }
-  }
-}
-
-TEST(FastMathTest, IntLog2CeilTest) {
-  using absl::random_internal::IntLog2Ceil;
-  constexpr uint64_t kZero = 0;
-  EXPECT_EQ(0, IntLog2Ceil(0));  // boundary. return 0.
-  EXPECT_EQ(0, IntLog2Ceil(1));
-  EXPECT_EQ(1, IntLog2Ceil(2));
-  EXPECT_EQ(64, IntLog2Ceil(~kZero));
-
-  // A boundary case: Converting 0xffffffffffffffff requires > 53
-  // bits of precision, so the conversion to double rounds up,
-  // and the result of std::log2(x) > IntLog2Floor(x).
-  EXPECT_LE(IntLog2Ceil(~kZero), static_cast<int>(std::log2(~kZero)));
-
-  for (int i = 0; i < 64; i++) {
-    const uint64_t i_pow_2 = static_cast<uint64_t>(1) << i;
-    EXPECT_EQ(i, IntLog2Ceil(i_pow_2));
-#ifndef ABSL_RANDOM_INACCURATE_LOG2
-    EXPECT_EQ(i, static_cast<int>(std::ceil(std::log2(i_pow_2))));
-#endif
-
-    uint64_t y = i_pow_2;
-    for (int j = i - 1; j > 0; --j) {
-      y = y | (i_pow_2 >> j);
-      EXPECT_EQ(i + 1, IntLog2Ceil(y));
-    }
-  }
-}
-
-TEST(FastMathTest, StirlingLogFactorial) {
-  using absl::random_internal::StirlingLogFactorial;
-
-  EXPECT_NEAR(StirlingLogFactorial(1.0), 0, 1e-3);
-  EXPECT_NEAR(StirlingLogFactorial(1.50), 0.284683, 1e-3);
-  EXPECT_NEAR(StirlingLogFactorial(2.0), 0.69314718056, 1e-4);
-
-  for (int i = 2; i < 50; i++) {
-    double d = static_cast<double>(i);
-    EXPECT_NEAR(StirlingLogFactorial(d), std::lgamma(d + 1), 3e-5);
-  }
-}
-
-}  // namespace

package/deps/abseil-cpp/absl/random/internal/gaussian_distribution_gentables.cc

@@ -1,142 +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.
-
-// Generates gaussian_distribution.cc
-//
-// $ blaze run :gaussian_distribution_gentables > gaussian_distribution.cc
-//
-#include <cmath>
-#include <cstddef>
-#include <iostream>
-#include <limits>
-#include <string>
-
-#include "absl/base/macros.h"
-#include "absl/random/gaussian_distribution.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace random_internal {
-namespace {
-
-template <typename T, size_t N>
-void FormatArrayContents(std::ostream* os, T (&data)[N]) {
-  if (!std::numeric_limits<T>::is_exact) {
-    // Note: T is either an integer or a float.
-    // float requires higher precision to ensure that values are
-    // reproduced exactly.
-    // Trivia: C99 has hexadecimal floating point literals, but C++11 does not.
-    // Using them would remove all concern of precision loss.
-    os->precision(std::numeric_limits<T>::max_digits10 + 2);
-  }
-  *os << "    {";
-  std::string separator = "";
-  for (size_t i = 0; i < N; ++i) {
-    *os << separator << data[i];
-    if ((i + 1) % 3 != 0) {
-      separator = ", ";
-    } else {
-      separator = ",\n     ";
-    }
-  }
-  *os << "}";
-}
-
-}  // namespace
-
-class TableGenerator : public gaussian_distribution_base {
- public:
-  TableGenerator();
-  void Print(std::ostream* os);
-
-  using gaussian_distribution_base::kMask;
-  using gaussian_distribution_base::kR;
-  using gaussian_distribution_base::kV;
-
- private:
-  Tables tables_;
-};
-
-// Ziggurat gaussian initialization.  For an explanation of the algorithm, see
-// the Marsaglia paper, "The Ziggurat Method for Generating Random Variables".
-//   http://www.jstatsoft.org/v05/i08/
-//
-// Further details are available in the Doornik paper
-//   https://www.doornik.com/research/ziggurat.pdf
-//
-TableGenerator::TableGenerator() {
-  // The constants here should match the values in gaussian_distribution.h
-  static constexpr int kC = kMask + 1;
-
-  static_assert((ABSL_ARRAYSIZE(tables_.x) == kC + 1),
-                "xArray must be length kMask + 2");
-
-  static_assert((ABSL_ARRAYSIZE(tables_.x) == ABSL_ARRAYSIZE(tables_.f)),
-                "fx and x arrays must be identical length");
-
-  auto f = [](double x) { return std::exp(-0.5 * x * x); };
-  auto f_inv = [](double x) { return std::sqrt(-2.0 * std::log(x)); };
-
-  tables_.x[0] = kV / f(kR);
-  tables_.f[0] = f(tables_.x[0]);
-
-  tables_.x[1] = kR;
-  tables_.f[1] = f(tables_.x[1]);
-
-  tables_.x[kC] = 0.0;
-  tables_.f[kC] = f(tables_.x[kC]);  // 1.0
-
-  for (int i = 2; i < kC; i++) {
-    double v = (kV / tables_.x[i - 1]) + tables_.f[i - 1];
-    tables_.x[i] = f_inv(v);
-    tables_.f[i] = v;
-  }
-}
-
-void TableGenerator::Print(std::ostream* os) {
-  *os << "// BEGIN GENERATED CODE; DO NOT EDIT\n"
-         "// clang-format off\n"
-         "\n"
-         "#include \"absl/random/gaussian_distribution.h\"\n"
-         "\n"
-         "namespace absl {\n"
-         "ABSL_NAMESPACE_BEGIN\n"
-         "namespace random_internal {\n"
-         "\n"
-         "const gaussian_distribution_base::Tables\n"
-         "    gaussian_distribution_base::zg_ = {\n";
-  FormatArrayContents(os, tables_.x);
-  *os << ",\n";
-  FormatArrayContents(os, tables_.f);
-  *os << "};\n"
-         "\n"
-         "}  // namespace random_internal\n"
-         "ABSL_NAMESPACE_END\n"
-         "}  // namespace absl\n"
-         "\n"
-         "// clang-format on\n"
-         "// END GENERATED CODE";
-  *os << std::endl;
-}
-
-}  // namespace random_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-int main(int, char**) {
-  std::cerr << "\nCopy the output to gaussian_distribution.cc" << std::endl;
-  absl::random_internal::TableGenerator generator;
-  generator.Print(&std::cout);
-  return 0;
-}