1 files changed, 0 insertions, 193 deletions
diff --git a/third_party/abseil_cpp/absl/random/internal/distribution_test_util_test.cc b/third_party/abseil_cpp/absl/random/internal/distribution_test_util_test.cc
deleted file mode 100644
index c49d44fb47..0000000000
--- a/third_party/abseil_cpp/absl/random/internal/distribution_test_util_test.cc
+++ /dev/null
@@ -1,193 +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/distribution_test_util.h"
-
-#include "gtest/gtest.h"
-
-namespace {
-
-TEST(TestUtil, InverseErf) {
-  const struct {
-    const double z;
-    const double value;
-  } kErfInvTable[] = {
-      {0.0000001, 8.86227e-8},
-      {0.00001, 8.86227e-6},
-      {0.5, 0.4769362762044},
-      {0.6, 0.5951160814499},
-      {0.99999, 3.1234132743},
-      {0.9999999, 3.7665625816},
-      {0.999999944, 3.8403850690566985},  // = log((1-x) * (1+x)) =~ 16.004
-      {0.999999999, 4.3200053849134452},
-  };
-
-  for (const auto& data : kErfInvTable) {
-    auto value = absl::random_internal::erfinv(data.z);
-
-    // Log using the Wolfram-alpha function name & parameters.
-    EXPECT_NEAR(value, data.value, 1e-8)
-        << " InverseErf[" << data.z << "]  (expected=" << data.value << ")  -> "
-        << value;
-  }
-}
-
-const struct {
-  const double p;
-  const double q;
-  const double x;
-  const double alpha;
-} kBetaTable[] = {
-    {0.5, 0.5, 0.01, 0.06376856085851985},
-    {0.5, 0.5, 0.1, 0.2048327646991335},
-    {0.5, 0.5, 1, 1},
-    {1, 0.5, 0, 0},
-    {1, 0.5, 0.01, 0.005012562893380045},
-    {1, 0.5, 0.1, 0.0513167019494862},
-    {1, 0.5, 0.5, 0.2928932188134525},
-    {1, 1, 0.5, 0.5},
-    {2, 2, 0.1, 0.028},
-    {2, 2, 0.2, 0.104},
-    {2, 2, 0.3, 0.216},
-    {2, 2, 0.4, 0.352},
-    {2, 2, 0.5, 0.5},
-    {2, 2, 0.6, 0.648},
-    {2, 2, 0.7, 0.784},
-    {2, 2, 0.8, 0.896},
-    {2, 2, 0.9, 0.972},
-    {5.5, 5, 0.5, 0.4361908850559777},
-    {10, 0.5, 0.9, 0.1516409096346979},
-    {10, 5, 0.5, 0.08978271484375},
-    {10, 5, 1, 1},
-    {10, 10, 0.5, 0.5},
-    {20, 5, 0.8, 0.4598773297575791},
-    {20, 10, 0.6, 0.2146816102371739},
-    {20, 10, 0.8, 0.9507364826957875},
-    {20, 20, 0.5, 0.5},
-    {20, 20, 0.6, 0.8979413687105918},
-    {30, 10, 0.7, 0.2241297491808366},
-    {30, 10, 0.8, 0.7586405487192086},
-    {40, 20, 0.7, 0.7001783247477069},
-    {1, 0.5, 0.1, 0.0513167019494862},
-    {1, 0.5, 0.2, 0.1055728090000841},
-    {1, 0.5, 0.3, 0.1633399734659245},
-    {1, 0.5, 0.4, 0.2254033307585166},
-    {1, 2, 0.2, 0.36},
-    {1, 3, 0.2, 0.488},
-    {1, 4, 0.2, 0.5904},
-    {1, 5, 0.2, 0.67232},
-    {2, 2, 0.3, 0.216},
-    {3, 2, 0.3, 0.0837},
-    {4, 2, 0.3, 0.03078},
-    {5, 2, 0.3, 0.010935},
-
-    // These values test small & large points along the range of the Beta
-    // function.
-    //
-    // When selecting test points, remember that if BetaIncomplete(x, p, q)
-    // returns the same value to within the limits of precision over a large
-    // domain of the input, x, then BetaIncompleteInv(alpha, p, q) may return an
-    // essentially arbitrary value where BetaIncomplete(x, p, q) =~ alpha.
-
-    // BetaRegularized[x, 0.00001, 0.00001],
-    // For x in {~0.001 ... ~0.999}, => ~0.5
-    {1e-5, 1e-5, 1e-5, 0.4999424388184638311},
-    {1e-5, 1e-5, (1.0 - 1e-8), 0.5000920948389232964},
-
-    // BetaRegularized[x, 0.00001, 10000].
-    // For x in {~epsilon ... 1.0}, => ~1
-    {1e-5, 1e5, 1e-6, 0.9999817708130066936},
-    {1e-5, 1e5, (1.0 - 1e-7), 1.0},
-
-    // BetaRegularized[x, 10000, 0.00001].
-    // For x in {0 .. 1-epsilon}, => ~0
-    {1e5, 1e-5, 1e-6, 0},
-    {1e5, 1e-5, (1.0 - 1e-6), 1.8229186993306369e-5},
-};
-
-TEST(BetaTest, BetaIncomplete) {
-  for (const auto& data : kBetaTable) {
-    auto value = absl::random_internal::BetaIncomplete(data.x, data.p, data.q);
-
-    // Log using the Wolfram-alpha function name & parameters.
-    EXPECT_NEAR(value, data.alpha, 1e-12)
-        << " BetaRegularized[" << data.x << ", " << data.p << ", " << data.q
-        << "]  (expected=" << data.alpha << ")  -> " << value;
-  }
-}
-
-TEST(BetaTest, BetaIncompleteInv) {
-  for (const auto& data : kBetaTable) {
-    auto value =
-        absl::random_internal::BetaIncompleteInv(data.p, data.q, data.alpha);
-
-    // Log using the Wolfram-alpha function name & parameters.
-    EXPECT_NEAR(value, data.x, 1e-6)
-        << " InverseBetaRegularized[" << data.alpha << ", " << data.p << ", "
-        << data.q << "]  (expected=" << data.x << ")  -> " << value;
-  }
-}
-
-TEST(MaxErrorTolerance, MaxErrorTolerance) {
-  std::vector<std::pair<double, double>> cases = {
-      {0.0000001, 8.86227e-8 * 1.41421356237},
-      {0.00001, 8.86227e-6 * 1.41421356237},
-      {0.5, 0.4769362762044 * 1.41421356237},
-      {0.6, 0.5951160814499 * 1.41421356237},
-      {0.99999, 3.1234132743 * 1.41421356237},
-      {0.9999999, 3.7665625816 * 1.41421356237},
-      {0.999999944, 3.8403850690566985 * 1.41421356237},
-      {0.999999999, 4.3200053849134452 * 1.41421356237}};
-  for (auto entry : cases) {
-    EXPECT_NEAR(absl::random_internal::MaxErrorTolerance(entry.first),
-                entry.second, 1e-8);
-  }
-}
-
-TEST(ZScore, WithSameMean) {
-  absl::random_internal::DistributionMoments m;
-  m.n = 100;
-  m.mean = 5;
-  m.variance = 1;
-  EXPECT_NEAR(absl::random_internal::ZScore(5, m), 0, 1e-12);
-
-  m.n = 1;
-  m.mean = 0;
-  m.variance = 1;
-  EXPECT_NEAR(absl::random_internal::ZScore(0, m), 0, 1e-12);
-
-  m.n = 10000;
-  m.mean = -5;
-  m.variance = 100;
-  EXPECT_NEAR(absl::random_internal::ZScore(-5, m), 0, 1e-12);
-}
-
-TEST(ZScore, DifferentMean) {
-  absl::random_internal::DistributionMoments m;
-  m.n = 100;
-  m.mean = 5;
-  m.variance = 1;
-  EXPECT_NEAR(absl::random_internal::ZScore(4, m), 10, 1e-12);
-
-  m.n = 1;
-  m.mean = 0;
-  m.variance = 1;
-  EXPECT_NEAR(absl::random_internal::ZScore(-1, m), 1, 1e-12);
-
-  m.n = 10000;
-  m.mean = -5;
-  m.variance = 100;
-  EXPECT_NEAR(absl::random_internal::ZScore(-4, m), -10, 1e-12);
-}
-}  // namespace