tests: drop coverage duplicated across suites

- value pins and error throws already covered by the test/prob fixtures
- Eigen-vectorized expect_ad covered by the generated vv/ffv variants

Author: GidonFrischkorn

test/unit/math/mix/prob/inv_gaussian_test.cpp

@@ -81,34 +81,6 @@ TEST_F(AgradRev, mathMixScalFun_inv_gaussian_lccdf_tails) {
   stan::test::expect_ad(f, 0.5, 0.1, 50.0);
 }
 
-TEST_F(AgradRev, mathMixScalFun_inv_gaussian_lpdf_vectorized) {
-  Eigen::VectorXd y(3);
-  y << 0.3, 1.2, 4.0;
-  Eigen::VectorXd mu(3);
-  mu << 0.5, 1.0, 2.0;
-  Eigen::VectorXd lambda(3);
-  lambda << 2.0, 5.0, 0.7;
-
-  auto f = [](const auto& y, const auto& mu, const auto& lambda) {
-    return stan::math::inv_gaussian_lpdf(y, mu, lambda);
-  };
-  stan::test::expect_ad(f, y, mu, lambda);
-}
-
-TEST_F(AgradRev, mathMixScalFun_inv_gaussian_lccdf_vectorized) {
-  Eigen::VectorXd y(3);
-  y << 0.3, 1.2, 4.0;
-  Eigen::VectorXd mu(3);
-  mu << 0.5, 1.0, 2.0;
-  Eigen::VectorXd lambda(3);
-  lambda << 2.0, 5.0, 0.7;
-
-  auto f = [](const auto& y, const auto& mu, const auto& lambda) {
-    return stan::math::inv_gaussian_lccdf(y, mu, lambda);
-  };
-  stan::test::expect_ad(f, y, mu, lambda);
-}
-
 // The cdf's partials scale by the whole-container product, which a scalar
 // test does not exercise.
 TEST_F(AgradRev, mathMixScalFun_inv_gaussian_cdf_vectorized) {
@@ -125,20 +97,6 @@ TEST_F(AgradRev, mathMixScalFun_inv_gaussian_cdf_vectorized) {
   stan::test::expect_ad(f, y, mu, lambda);
 }
 
-TEST_F(AgradRev, mathMixScalFun_inv_gaussian_lcdf_vectorized) {
-  Eigen::VectorXd y(3);
-  y << 0.3, 1.2, 4.0;
-  Eigen::VectorXd mu(3);
-  mu << 0.5, 1.0, 2.0;
-  Eigen::VectorXd lambda(3);
-  lambda << 2.0, 5.0, 0.7;
-
-  auto f = [](const auto& y, const auto& mu, const auto& lambda) {
-    return stan::math::inv_gaussian_lcdf(y, mu, lambda);
-  };
-  stan::test::expect_ad(f, y, mu, lambda);
-}
-
 TEST_F(AgradRev, mathMixScalFun_inv_gaussian_std_vector) {
   std::vector<double> y{0.3, 1.2, 4.0};
   std::vector<double> mu{0.5, 1.0, 2.0};

test/unit/math/prim/prob/inv_gaussian_test.cpp

@@ -43,21 +43,6 @@ TEST(ProbDistributionsInvGaussian, distributionCheck) {
   check_quantiles_real_real(InvGaussianTestRig());
 }
 
-TEST(ProbDistributionsInvGaussian, error_check) {
-  boost::random::mt19937 rng;
-  EXPECT_NO_THROW(stan::math::inv_gaussian_rng(1.0, 2.0, rng));
-  EXPECT_THROW(stan::math::inv_gaussian_rng(0.0, 2.0, rng), std::domain_error);
-  EXPECT_THROW(stan::math::inv_gaussian_rng(-1.0, 2.0, rng), std::domain_error);
-  EXPECT_THROW(stan::math::inv_gaussian_rng(1.0, 0.0, rng), std::domain_error);
-  EXPECT_THROW(stan::math::inv_gaussian_rng(1.0, -1.0, rng), std::domain_error);
-  EXPECT_THROW(
-      stan::math::inv_gaussian_rng(stan::math::positive_infinity(), 2.0, rng),
-      std::domain_error);
-  EXPECT_THROW(
-      stan::math::inv_gaussian_rng(1.0, stan::math::positive_infinity(), rng),
-      std::domain_error);
-}
-
 TEST(ProbDistributionsInvGaussian, rngStableForLargeMuOverLambda) {
   boost::random::mt19937 rng(1234);
   for (double mu : {1.0, 1e3, 1e6, 1e9, 1e12}) {
@@ -91,25 +76,6 @@ TEST(ProbDistributionsInvGaussian, rngMomentsAtLargeMu) {
   EXPECT_NEAR(mu * mu * mu / lambda, var, 0.15 * mu * mu * mu / lambda);
 }
 
-// reference values from mpmath at 60 digits
-
-TEST(ProbDistributionsInvGaussian, values) {
-  using stan::math::inv_gaussian_cdf;
-  using stan::math::inv_gaussian_lccdf;
-  using stan::math::inv_gaussian_lcdf;
-  using stan::math::inv_gaussian_lpdf;
-
-  EXPECT_FLOAT_EQ(-2.479180611448965157415, inv_gaussian_lpdf(1.2, 0.5, 2.0));
-  EXPECT_FLOAT_EQ(-2.391593703832052124008, inv_gaussian_lpdf(0.3, 1.0, 5.0));
-  EXPECT_FLOAT_EQ(0.9815922531042920910742, inv_gaussian_cdf(1.2, 0.5, 2.0));
-  EXPECT_FLOAT_EQ(0.003359190912064955560317, inv_gaussian_cdf(0.3, 1.0, 5.0));
-  EXPECT_FLOAT_EQ(-0.01857927772712011847827, inv_gaussian_lcdf(1.2, 0.5, 2.0));
-  EXPECT_FLOAT_EQ(-5.696055133984662592139, inv_gaussian_lcdf(0.3, 1.0, 5.0));
-  EXPECT_FLOAT_EQ(-3.9949836760335225255, inv_gaussian_lccdf(1.2, 0.5, 2.0));
-  EXPECT_FLOAT_EQ(-0.003364845660995599504277,
-                  inv_gaussian_lccdf(0.3, 1.0, 5.0));
-}
-
 TEST(ProbDistributionsInvGaussian, boundaries) {
   using stan::math::inv_gaussian_cdf;
   using stan::math::inv_gaussian_lccdf;
@@ -153,6 +119,7 @@ TEST(ProbDistributionsInvGaussian, boundariesInContainer) {
 }
 
 // 2 lambda / mu is past the overflow point of exp for all of these.
+// reference values from mpmath at 60 digits
 TEST(ProbDistributionsInvGaussian, largeExpFactor) {
   using stan::math::inv_gaussian_lccdf;
   using stan::math::inv_gaussian_lcdf;
@@ -248,24 +215,6 @@ TEST(ProbDistributionsInvGaussian, cdfCcdfSumToOne) {
   }
 }
 
-TEST(ProbDistributionsInvGaussian, vectorMatchesScalarSum) {
-  using stan::math::inv_gaussian_lccdf;
-  using stan::math::inv_gaussian_lcdf;
-  using stan::math::inv_gaussian_lpdf;
-  std::vector<double> y{0.2, 0.5, 1.0, 2.0, 5.0};
-  double sum_lpdf = 0;
-  double sum_lcdf = 0;
-  double sum_lccdf = 0;
-  for (double yi : y) {
-    sum_lpdf += inv_gaussian_lpdf(yi, 1.3, 3.0);
-    sum_lcdf += inv_gaussian_lcdf(yi, 1.3, 3.0);
-    sum_lccdf += inv_gaussian_lccdf(yi, 1.3, 3.0);
-  }
-  EXPECT_FLOAT_EQ(sum_lpdf, inv_gaussian_lpdf(y, 1.3, 3.0));
-  EXPECT_FLOAT_EQ(sum_lcdf, inv_gaussian_lcdf(y, 1.3, 3.0));
-  EXPECT_FLOAT_EQ(sum_lccdf, inv_gaussian_lccdf(y, 1.3, 3.0));
-}
-
 // check helper functions; tolerances scale with each value's magnitude
 TEST(ProbDistributionsInvGaussian, internalLogPhi) {
   using stan::math::internal::log_Phi;
@@ -294,29 +243,16 @@ TEST(ProbDistributionsInvGaussian, internalLogPhi) {
   EXPECT_FLOAT_EQ(0.0, log_Phi(inf));
   EXPECT_FLOAT_EQ(-inf, log_Phi(-inf));
   EXPECT_TRUE(std::isnan(log_Phi(std::numeric_limits<double>::quiet_NaN())));
-}
 
-// The true slope at z = -30 is about 30, so across a 2e-10 interval the
-// honest change is about 6e-9.
-TEST(ProbDistributionsInvGaussian, internalLogPhiBranchContinuity) {
-  using stan::math::internal::log_Phi;
+  // branch continuity: the true slope at z = -30 is about 30, so across a
+  // 2e-10 interval the honest change is about 6e-9
   double eps = 1e-10;
   double step = log_Phi(-30.0 + eps) - log_Phi(-30.0 - eps);
   EXPECT_LT(std::fabs(step), 1e-7);
 }
 
-TEST(ProbDistributionsInvGaussian, errors) {
+TEST(ProbDistributionsInvGaussian, sizeMismatch) {
   using stan::math::inv_gaussian_lpdf;
-  double inf = std::numeric_limits<double>::infinity();
-
-  EXPECT_THROW(inv_gaussian_lpdf(-1.0, 1.0, 2.0), std::domain_error);
-  EXPECT_THROW(inv_gaussian_lpdf(1.0, 0.0, 2.0), std::domain_error);
-  EXPECT_THROW(inv_gaussian_lpdf(1.0, -1.0, 2.0), std::domain_error);
-  EXPECT_THROW(inv_gaussian_lpdf(1.0, inf, 2.0), std::domain_error);
-  EXPECT_THROW(inv_gaussian_lpdf(1.0, 1.0, 0.0), std::domain_error);
-  EXPECT_THROW(inv_gaussian_lpdf(1.0, 1.0, -1.0), std::domain_error);
-  EXPECT_THROW(inv_gaussian_lpdf(1.0, 1.0, inf), std::domain_error);
-
   std::vector<double> y{1.0, 2.0};
   std::vector<double> mu{1.0, 2.0, 3.0};
   EXPECT_THROW(inv_gaussian_lpdf(y, mu, 1.0), std::invalid_argument);

test/unit/math/rev/prob/inv_gaussian_test.cpp

@@ -3,7 +3,6 @@
 #include <gtest/gtest.h>
 #include <functional>
 #include <limits>
-#include <vector>
 
 namespace {
 
@@ -199,65 +198,11 @@ TEST_F(AgradRev, inv_gaussian_boundary_partials_are_zero) {
   }
 }
 
-// A y == 0 element contributes a log survivor of zero and leaves the other
-// elements alone, gradients included.
-TEST_F(AgradRev, inv_gaussian_lccdf_zero_boundary_is_elementwise) {
-  using stan::math::var;
-  using stan::math::vector_v;
-
-  EXPECT_FLOAT_EQ(0.0, stan::math::inv_gaussian_lccdf(0.0, 1.0, 2.0));
-
-  std::vector<double> y{0.0, 5.0};
-  EXPECT_FLOAT_EQ(stan::math::inv_gaussian_lccdf(5.0, 1.0, 2.0),
-                  stan::math::inv_gaussian_lccdf(y, 1.0, 2.0));
-
-  vector_v y_v(2);
-  y_v << 0.0, 5.0;
-  var mu = 1.0;
-  var lambda = 2.0;
-  var out = stan::math::inv_gaussian_lccdf(y_v, mu, lambda);
-  out.grad();
-  double adj_boundary = y_v(0).adj();
-  double adj_finite = y_v(1).adj();
-  double adj_mu = mu.adj();
-  double adj_lambda = lambda.adj();
-  stan::math::recover_memory();
-
-  var y_s = 5.0;
-  var mu_s = 1.0;
-  var lambda_s = 2.0;
-  var out_s = stan::math::inv_gaussian_lccdf(y_s, mu_s, lambda_s);
-  out_s.grad();
-  EXPECT_FLOAT_EQ(0.0, adj_boundary);
-  EXPECT_FLOAT_EQ(y_s.adj(), adj_finite);
-  EXPECT_FLOAT_EQ(mu_s.adj(), adj_mu);
-  EXPECT_FLOAT_EQ(lambda_s.adj(), adj_lambda);
-  stan::math::recover_memory();
-}
-
-// Deep in the upper tail the survivor's two terms agree to the last bit and
-// the guarded difference underflows to -inf at a finite y. The partials are
-// zero there, and the guard fires deterministically at these points.
-TEST_F(AgradRev, inv_gaussian_lccdf_underflow_partials_are_zero) {
-  using stan::math::var;
-  double inf = std::numeric_limits<double>::infinity();
-  for (double y_dbl : {1e-2, 1.0, 10.0}) {
-    var y = y_dbl;
-    var mu = 1e-3;
-    var lambda = 1e14;
-    var out = stan::math::inv_gaussian_lccdf(y, mu, lambda);
-    EXPECT_FLOAT_EQ(-inf, out.val()) << "y=" << y_dbl;
-    out.grad();
-    EXPECT_FLOAT_EQ(0.0, y.adj()) << "y=" << y_dbl;
-    EXPECT_FLOAT_EQ(0.0, mu.adj()) << "y=" << y_dbl;
-    EXPECT_FLOAT_EQ(0.0, lambda.adj()) << "y=" << y_dbl;
-    stan::math::recover_memory();
-  }
-}
-
-// lambda / y overflows for representable arguments, saturating the log CDF to
-// -inf at an interior y. The saturation mask zeroes every partial there.
-TEST_F(AgradRev, inv_gaussian_saturation_partials_are_zero) {
+// The log probability saturates to -inf at an interior y in two ways: the
+// guarded survivor difference underflows deep in the upper tail, and
+// lambda / y overflows for representable arguments. Both trigger the same
+// mask, which zeroes every partial.
+TEST_F(AgradRev, inv_gaussian_saturated_partials_are_zero) {
   using stan::math::var;
   double inf = std::numeric_limits<double>::infinity();
 
@@ -291,36 +236,52 @@ TEST_F(AgradRev, inv_gaussian_saturation_partials_are_zero) {
   check(cdf, 1e-10, 1.0, 1e300, 0.0, "cdf");
   // y is above mu, so the survivor saturates
   check(lccdf, 2e-3, 1e-3, 1e308, -inf, "lccdf");
+  // survivor underflow: the two lccdf terms agree to the last bit
+  check(lccdf, 1e-2, 1e-3, 1e14, -inf, "lccdf underflow");
+  check(lccdf, 1.0, 1e-3, 1e14, -inf, "lccdf underflow");
+  check(lccdf, 10.0, 1e-3, 1e14, -inf, "lccdf underflow");
 }
 
-// The same for the y == inf boundary of the lcdf and cdf.
-TEST_F(AgradRev, inv_gaussian_inf_boundary_is_elementwise) {
+// A boundary element leaves the other elements' adjoints alone; the
+// container values themselves are pinned in the prim suite.
+TEST_F(AgradRev, inv_gaussian_boundary_adjoints_are_elementwise) {
   using stan::math::var;
   using stan::math::vector_v;
   double inf = std::numeric_limits<double>::infinity();
 
-  vector_v y_v(2);
-  y_v << inf, 0.5;
-  var mu = 1.0;
-  var lambda = 2.0;
-  var out = stan::math::inv_gaussian_lcdf(y_v, mu, lambda);
-  out.grad();
-  double vec_val = out.val();
-  double adj_boundary = y_v(0).adj();
-  double adj_finite = y_v(1).adj();
-  double adj_mu = mu.adj();
-  double adj_lambda = lambda.adj();
-  stan::math::recover_memory();
+  auto check = [](auto f, double boundary, double finite) {
+    vector_v y_v(2);
+    y_v << boundary, finite;
+    var mu = 1.0;
+    var lambda = 2.0;
+    var out = f(y_v, mu, lambda);
+    out.grad();
+    double adj_boundary = y_v(0).adj();
+    double adj_finite = y_v(1).adj();
+    double adj_mu = mu.adj();
+    double adj_lambda = lambda.adj();
+    stan::math::recover_memory();
 
-  var y_s = 0.5;
-  var mu_s = 1.0;
-  var lambda_s = 2.0;
-  var out_s = stan::math::inv_gaussian_lcdf(y_s, mu_s, lambda_s);
-  out_s.grad();
-  EXPECT_FLOAT_EQ(out_s.val(), vec_val);
-  EXPECT_FLOAT_EQ(0.0, adj_boundary);
-  EXPECT_FLOAT_EQ(y_s.adj(), adj_finite);
-  EXPECT_FLOAT_EQ(mu_s.adj(), adj_mu);
-  EXPECT_FLOAT_EQ(lambda_s.adj(), adj_lambda);
-  stan::math::recover_memory();
+    var y_s = finite;
+    var mu_s = 1.0;
+    var lambda_s = 2.0;
+    var out_s = f(y_s, mu_s, lambda_s);
+    out_s.grad();
+    EXPECT_FLOAT_EQ(0.0, adj_boundary);
+    EXPECT_FLOAT_EQ(y_s.adj(), adj_finite);
+    EXPECT_FLOAT_EQ(mu_s.adj(), adj_mu);
+    EXPECT_FLOAT_EQ(lambda_s.adj(), adj_lambda);
+    stan::math::recover_memory();
+  };
+
+  check(
+      [](const auto& y, const auto& mu, const auto& lambda) {
+        return stan::math::inv_gaussian_lccdf(y, mu, lambda);
+      },
+      0.0, 5.0);
+  check(
+      [](const auto& y, const auto& mu, const auto& lambda) {
+        return stan::math::inv_gaussian_lcdf(y, mu, lambda);
+      },
+      inf, 0.5);
 }