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

Author: stan-buildbot

stan/math/prim/fun/log_gamma_q_dgamma.hpp

@@ -42,7 +42,9 @@ inline return_type_t<T_a, T_z> log_q_gamma_cf(const T_a& a, const T_z& z,
   const T_return log_prefactor = a * log(z) - z - lgamma(a);
 
   T_return b_init = z + 1.0 - a;
-  T_return C = (fabs(value_of(b_init)) >= EPSILON) ? b_init : std::decay_t<decltype(b_init)>(EPSILON);
+  T_return C = (fabs(value_of(b_init)) >= EPSILON)
+                   ? b_init
+                   : std::decay_t<decltype(b_init)>(EPSILON);
   T_return D = 0.0;
   T_return f = C;
   for (int i = 1; i <= max_steps; ++i) {
@@ -83,14 +85,16 @@ inline return_type_t<T_a, T_z> log_q_gamma_cf(const T_a& a, const T_z& z,
  * @return structure containing log(Q(a,z)) and d/da log(Q(a,z))
  */
 template <typename T_a, typename T_z>
-inline std::pair<return_type_t<T_a, T_z>, return_type_t<T_a, T_z>> log_gamma_q_dgamma(
-    const T_a& a, const T_z& z, double precision = 1.49012e-08, int max_steps = 250) {
+inline std::pair<return_type_t<T_a, T_z>, return_type_t<T_a, T_z>>
+log_gamma_q_dgamma(const T_a& a, const T_z& z, double precision = 1.49012e-08,
+                   int max_steps = 250) {
   using T_return = return_type_t<T_a, T_z>;
   const double a_val = value_of(a);
   const double z_val = value_of(z);
   // For z > a + 1, use continued fraction for better numerical stability
   if (z_val > a_val + 1.0) {
-    std::pair<T_return, T_return> result{internal::log_q_gamma_cf(a_val, z_val, precision, max_steps), 0.0};
+    std::pair<T_return, T_return> result{
+        internal::log_q_gamma_cf(a_val, z_val, precision, max_steps), 0.0};
     // For gradient, use: d/da log(Q) = (1/Q) * dQ/da
     // grad_reg_inc_gamma computes dQ/da
     const T_return Q_val = exp(result.first);

stan/math/prim/prob/gamma_lccdf.hpp

@@ -31,7 +31,8 @@ namespace internal {
 /**
  * Computes log q and d(log q) / d(alpha) using continued fraction.
  */
-template <bool any_fvar, bool partials_fvar, typename T_shape, typename T1, typename T2>
+template <bool any_fvar, bool partials_fvar, typename T_shape, typename T1,
+          typename T2>
 inline std::optional<std::pair<return_type_t<T1, T2>, return_type_t<T1, T2>>>
 eval_q_cf(const T1& alpha, const T2& beta_y) {
   using scalar_t = return_type_t<T1, T2>;
@@ -88,8 +89,7 @@ eval_q_log1m(const T1& alpha, const T2& beta_y) {
       auto log_Q_fvar = log1m(gamma_p(alpha_unit, beta_unit));
       out.second = log_Q_fvar.d_;
     } else {
-      out.second
-          = -grad_reg_lower_inc_gamma(alpha, beta_y) / exp(out.first);
+      out.second = -grad_reg_lower_inc_gamma(alpha, beta_y) / exp(out.first);
     }
   }
   return std::optional{out};
@@ -152,12 +152,15 @@ inline return_type_t<T_y, T_shape, T_inv_scale> gamma_lccdf(
     }
     std::optional<std::pair<T_partials_return, T_partials_return>> result;
     if (beta_y > alpha_val + 1.0) {
-      result = internal::eval_q_cf<any_fvar, partials_fvar, T_shape>(alpha_val, beta_y);
+      result = internal::eval_q_cf<any_fvar, partials_fvar, T_shape>(alpha_val,
+                                                                     beta_y);
     } else {
-      result = internal::eval_q_log1m<partials_fvar, T_shape>(alpha_val, beta_y);
+      result
+          = internal::eval_q_log1m<partials_fvar, T_shape>(alpha_val, beta_y);
       if (!result && beta_y > 0.0) {
         // Fallback to continued fraction if log1m fails
-        result = internal::eval_q_cf<any_fvar, partials_fvar, T_shape>(alpha_val, beta_y);
+        result = internal::eval_q_cf<any_fvar, partials_fvar, T_shape>(
+            alpha_val, beta_y);
       }
     }
     if (unlikely(!result)) {