random/internal/distribution_test_util_test.cc

// 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