[Jenkins] auto-formatting by clang-format version 10.0.0-4ubuntu1

Author: stan-buildbot

stan/math/prim/prob/gamma_lccdf.hpp

@@ -85,10 +85,9 @@ return_type_t<T_y, T_shape, T_inv_scale> gamma_lccdf(const T_y& y,
     if constexpr (is_any_autodiff_v<T_y, T_inv_scale>) {
       const T_partials_return log_y_dbl = log(y_dbl);
       const T_partials_return log_beta_dbl = log(beta_dbl);
-      const T_partials_return log_pdf = alpha_dbl * log_beta_dbl
-                                  - lgamma(alpha_dbl)
-                                  + (alpha_dbl - 1.0) * log_y_dbl
-                                  - beta_y_dbl;
+      const T_partials_return log_pdf
+          = alpha_dbl * log_beta_dbl - lgamma(alpha_dbl)
+            + (alpha_dbl - 1.0) * log_y_dbl - beta_y_dbl;
       const T_partials_return common_term = exp(log_pdf - log_Qn);
 
       if constexpr (is_autodiff_v<T_y>) {
@@ -104,9 +103,10 @@ return_type_t<T_y, T_shape, T_inv_scale> gamma_lccdf(const T_y& y,
     if constexpr (is_autodiff_v<T_shape>) {
       const T_partials_return digamma_val = digamma(alpha_dbl);
       const T_partials_return gamma_val = tgamma(alpha_dbl);
-        // d/dalpha log(1-F(y)) = grad_upper_inc_gamma / (1-F(y))
-        partials<1>(ops_partials)[n]
-            += grad_reg_inc_gamma(alpha_dbl, beta_y_dbl, gamma_val, digamma_val) / Qn;
+      // d/dalpha log(1-F(y)) = grad_upper_inc_gamma / (1-F(y))
+      partials<1>(ops_partials)[n]
+          += grad_reg_inc_gamma(alpha_dbl, beta_y_dbl, gamma_val, digamma_val)
+             / Qn;
     }
   }
   return ops_partials.build(P);

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

@@ -86,7 +86,8 @@ TEST(ProbGamma, lccdf_alpha_one) {
   using std::log;
 
   // When alpha = 1, gamma becomes exponential
-  // For exponential with rate beta: LCCDF(y) = log(1 - (1-exp(-beta*y))) = log(exp(-beta*y)) = -beta*y
+  // For exponential with rate beta: LCCDF(y) = log(1 - (1-exp(-beta*y))) =
+  // log(exp(-beta*y)) = -beta*y
   double y = 2.0;
   double alpha = 1.0;
   double beta = 3.0;
@@ -102,14 +103,14 @@ TEST(ProbGamma, lccdf_various_values) {
 
   // Test a variety of parameter combinations
   std::vector<std::tuple<double, double, double>> test_cases = {
-      {0.5, 0.5, 1.0},    // Small y, small alpha
-      {1.0, 1.0, 1.0},    // All ones
-      {2.0, 3.0, 0.5},    // Moderate values
-      {10.0, 2.0, 0.1},   // Large y, small beta
-      {0.1, 10.0, 2.0},   // Small y, large alpha
-      {5.0, 5.0, 1.0},    // Equal alpha and y
-      {0.01, 0.5, 10.0},  // Small y, large beta
-      {100.0, 100.0, 1.0} // Large matched values
+      {0.5, 0.5, 1.0},     // Small y, small alpha
+      {1.0, 1.0, 1.0},     // All ones
+      {2.0, 3.0, 0.5},     // Moderate values
+      {10.0, 2.0, 0.1},    // Large y, small beta
+      {0.1, 10.0, 2.0},    // Small y, large alpha
+      {5.0, 5.0, 1.0},     // Equal alpha and y
+      {0.01, 0.5, 10.0},   // Small y, large beta
+      {100.0, 100.0, 1.0}  // Large matched values
   };
 
   for (const auto& test_case : test_cases) {
@@ -122,8 +123,8 @@ TEST(ProbGamma, lccdf_various_values) {
     // All results should be finite and <= 0
     EXPECT_TRUE(std::isfinite(result))
         << "Failed for y=" << y << ", alpha=" << alpha << ", beta=" << beta;
-    EXPECT_LE(result, 0.0)
-        << "Failed for y=" << y << ", alpha=" << alpha << ", beta=" << beta;
+    EXPECT_LE(result, 0.0) << "Failed for y=" << y << ", alpha=" << alpha
+                           << ", beta=" << beta;
   }
 }
 
@@ -173,8 +174,8 @@ TEST(ProbGamma, lccdf_monotonic_in_y) {
 }
 
 TEST(ProbGamma, lccdf_consistency_with_cdf) {
-  using stan::math::gamma_lccdf;
   using stan::math::gamma_cdf;
+  using stan::math::gamma_lccdf;
   using std::log;
 
   // Test that lccdf(y) ≈ log(1 - cdf(y))
@@ -194,12 +195,12 @@ TEST(ProbGamma, lccdf_numerically_challenging) {
 
   // Test cases that might cause numerical issues
   std::vector<std::tuple<double, double, double>> challenging_cases = {
-      {1e-8, 1e-6, 1.0},       // Very small y and alpha
-      {1e-6, 100.0, 1e-3},     // Very small y, large alpha, small beta
-      {1000.0, 0.1, 1e-4},     // Large y, small alpha, very small beta
-      {50.0, 50.0, 1.0},       // Matched moderate values
-      {0.001, 0.001, 100.0},   // Small y and alpha, large beta
-      {1e6, 10.0, 1e-6},       // Very large y, moderate alpha, very small beta
+      {1e-8, 1e-6, 1.0},      // Very small y and alpha
+      {1e-6, 100.0, 1e-3},    // Very small y, large alpha, small beta
+      {1000.0, 0.1, 1e-4},    // Large y, small alpha, very small beta
+      {50.0, 50.0, 1.0},      // Matched moderate values
+      {0.001, 0.001, 100.0},  // Small y and alpha, large beta
+      {1e6, 10.0, 1e-6},      // Very large y, moderate alpha, very small beta
   };
 
   for (const auto& test_case : challenging_cases) {
@@ -214,8 +215,8 @@ TEST(ProbGamma, lccdf_numerically_challenging) {
         << "NaN for y=" << y << ", alpha=" << alpha << ", beta=" << beta;
 
     // Should be <= 0 (log of probability)
-    EXPECT_LE(result, 0.0)
-        << "Positive value for y=" << y << ", alpha=" << alpha << ", beta=" << beta;
+    EXPECT_LE(result, 0.0) << "Positive value for y=" << y
+                           << ", alpha=" << alpha << ", beta=" << beta;
   }
 }
 

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

@@ -115,7 +115,8 @@ TEST(ProbDistributionsGamma, lccdf_derivatives_all_params) {
   // Check all gradients are finite and not NaN
   for (size_t i = 0; i < grads.size(); ++i) {
     EXPECT_FALSE(std::isnan(grads[i])) << "Gradient " << i << " is NaN";
-    EXPECT_TRUE(std::isfinite(grads[i])) << "Gradient " << i << " is not finite";
+    EXPECT_TRUE(std::isfinite(grads[i]))
+        << "Gradient " << i << " is not finite";
   }
 
   // d/dy should be negative
@@ -291,12 +292,8 @@ TEST(ProbDistributionsGamma, lccdf_various_parameter_combinations) {
   using stan::math::var;
 
   std::vector<std::tuple<double, double, double>> test_cases = {
-      {0.5, 0.5, 1.0},
-      {1.0, 1.0, 1.0},
-      {2.0, 3.0, 0.5},
-      {10.0, 2.0, 0.1},
-      {0.1, 10.0, 2.0},
-      {5.0, 5.0, 1.0},
+      {0.5, 0.5, 1.0},  {1.0, 1.0, 1.0},  {2.0, 3.0, 0.5},
+      {10.0, 2.0, 0.1}, {0.1, 10.0, 2.0}, {5.0, 5.0, 1.0},
   };
 
   for (const auto& test_case : test_cases) {
@@ -354,10 +351,10 @@ TEST(ProbDistributionsGamma, lccdf_numerically_challenging_derivatives) {
 
   // Test numerically challenging cases
   std::vector<std::tuple<double, double, double>> challenging_cases = {
-      {1e-6, 1e-5, 1.0},        // Very small y and alpha
-      {0.001, 100.0, 0.01},     // Small y, large alpha, small beta
-      {1000.0, 0.5, 1e-3},      // Large y, small alpha, very small beta
-      {50.0, 50.0, 1.0},        // Matched moderate values
+      {1e-6, 1e-5, 1.0},     // Very small y and alpha
+      {0.001, 100.0, 0.01},  // Small y, large alpha, small beta
+      {1000.0, 0.5, 1e-3},   // Large y, small alpha, very small beta
+      {50.0, 50.0, 1.0},     // Matched moderate values
   };
 
   for (const auto& test_case : challenging_cases) {

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

@@ -115,7 +115,8 @@ TEST(ProbDistributionsGamma, lcdf_derivatives_all_params) {
   // Check all gradients are finite and not NaN
   for (size_t i = 0; i < grads.size(); ++i) {
     EXPECT_FALSE(std::isnan(grads[i])) << "Gradient " << i << " is NaN";
-    EXPECT_TRUE(std::isfinite(grads[i])) << "Gradient " << i << " is not finite";
+    EXPECT_TRUE(std::isfinite(grads[i]))
+        << "Gradient " << i << " is not finite";
   }
 
   // d/dy should be positive
@@ -290,12 +291,8 @@ TEST(ProbDistributionsGamma, lcdf_various_parameter_combinations) {
   using stan::math::var;
 
   std::vector<std::tuple<double, double, double>> test_cases = {
-      {0.5, 0.5, 1.0},
-      {1.0, 1.0, 1.0},
-      {2.0, 3.0, 0.5},
-      {10.0, 2.0, 0.1},
-      {0.1, 10.0, 2.0},
-      {5.0, 5.0, 1.0},
+      {0.5, 0.5, 1.0},  {1.0, 1.0, 1.0},  {2.0, 3.0, 0.5},
+      {10.0, 2.0, 0.1}, {0.1, 10.0, 2.0}, {5.0, 5.0, 1.0},
   };
 
   for (const auto& test_case : test_cases) {
@@ -326,8 +323,8 @@ TEST(ProbDistributionsGamma, lcdf_various_parameter_combinations) {
 }
 
 TEST(ProbDistributionsGamma, lcdf_consistency_with_lccdf) {
-  using stan::math::gamma_lcdf;
   using stan::math::gamma_lccdf;
+  using stan::math::gamma_lcdf;
   using stan::math::var;
 
   // Test that lcdf and lccdf derivatives are related
@@ -388,10 +385,11 @@ TEST(ProbDistributionsGamma, lcdf_numerically_challenging_derivatives) {
 
   // Test numerically challenging cases
   std::vector<std::tuple<double, double, double>> challenging_cases = {
-      {1e-6, 1e-5, 1.0},        // Very small y and alpha
-      // {0.001, 100.0, 0.01},  // This case causes NaN - numerically too challenging
-      {1000.0, 0.5, 1e-3},      // Large y, small alpha, very small beta
-      {50.0, 50.0, 1.0},        // Matched moderate values
+      {1e-6, 1e-5, 1.0},  // Very small y and alpha
+      // {0.001, 100.0, 0.01},  // This case causes NaN - numerically too
+      // challenging
+      {1000.0, 0.5, 1e-3},  // Large y, small alpha, very small beta
+      {50.0, 50.0, 1.0},    // Matched moderate values
   };
 
   for (const auto& test_case : challenging_cases) {
@@ -437,7 +435,6 @@ TEST(ProbDistributionsGamma, lcdf_monotonic_derivative) {
     std::vector<double> grads;
     lcdf_var.grad(vars, grads);
 
-    EXPECT_GT(grads[0], 0.0)
-        << "d/dy should be positive for y=" << y_d;
+    EXPECT_GT(grads[0], 0.0) << "d/dy should be positive for y=" << y_d;
   }
 }