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

Author: stan-buildbot

stan/math/prim/prob/gamma_lccdf.hpp

@@ -26,84 +26,81 @@
 namespace stan {
 namespace math {
 namespace internal {
-  template <typename T>
-  struct Q_eval {
-    T log_Q{0.0};
-    T dlogQ_dalpha{0.0};
-    bool ok{false};
-  };
-
-  /**
-   * Computes log q and d(log q) / d(alpha) using continued fraction.
-   */
-  template <typename T, typename T_shape,
-            bool any_fvar, bool partials_fvar>
-  static inline Q_eval<T> eval_q_cf(const T& alpha,
-                                    const T& beta_y) {
-    Q_eval<T> out;
-    if constexpr (!any_fvar && is_autodiff_v<T_shape>) {
-      auto log_q_result = log_gamma_q_dgamma(value_of_rec(alpha), value_of_rec(beta_y));
-      out.log_Q = log_q_result.log_q;
-      out.dlogQ_dalpha = log_q_result.dlog_q_da;
-    } else {
-      out.log_Q = internal::log_q_gamma_cf(alpha, beta_y);
-      if constexpr (is_autodiff_v<T_shape>) {
-        if constexpr (!partials_fvar) {
-          out.dlogQ_dalpha
-            = grad_reg_inc_gamma(alpha, beta_y, tgamma(alpha),
-                                 digamma(alpha)) / exp(out.log_Q);
-        } else {
-          T alpha_unit = alpha;
-          alpha_unit.d_ = 1;
-          T beta_y_unit = beta_y;
-          beta_y_unit.d_ = 0;
-          T log_Q_fvar = internal::log_q_gamma_cf(alpha_unit, beta_y_unit);
-          out.dlogQ_dalpha = log_Q_fvar.d_;
-        }
-      }
-    }
-
-    out.ok = std::isfinite(value_of_rec(out.log_Q));
-    return out;
-  }
-
-  /**
-   * Computes log q and d(log q) / d(alpha) using log1m.
-   */
-  template <typename T, typename T_shape,
-            bool partials_fvar>
-  static inline Q_eval<T> eval_q_log1m(const T& alpha,
-                                       const T& beta_y) {
-    Q_eval<T> out;
-    out.log_Q = log1m(gamma_p(alpha, beta_y));
-
-    if (!std::isfinite(value_of_rec(out.log_Q))) {
-      out.ok = false;
-      return out;
-    }
-
+template <typename T>
+struct Q_eval {
+  T log_Q{0.0};
+  T dlogQ_dalpha{0.0};
+  bool ok{false};
+};
+
+/**
+ * Computes log q and d(log q) / d(alpha) using continued fraction.
+ */
+template <typename T, typename T_shape, bool any_fvar, bool partials_fvar>
+static inline Q_eval<T> eval_q_cf(const T& alpha, const T& beta_y) {
+  Q_eval<T> out;
+  if constexpr (!any_fvar && is_autodiff_v<T_shape>) {
+    auto log_q_result
+        = log_gamma_q_dgamma(value_of_rec(alpha), value_of_rec(beta_y));
+    out.log_Q = log_q_result.log_q;
+    out.dlogQ_dalpha = log_q_result.dlog_q_da;
+  } else {
+    out.log_Q = internal::log_q_gamma_cf(alpha, beta_y);
     if constexpr (is_autodiff_v<T_shape>) {
-      if constexpr (partials_fvar) {
+      if constexpr (!partials_fvar) {
+        out.dlogQ_dalpha
+            = grad_reg_inc_gamma(alpha, beta_y, tgamma(alpha), digamma(alpha))
+              / exp(out.log_Q);
+      } else {
         T alpha_unit = alpha;
         alpha_unit.d_ = 1;
-        T beta_unit = beta_y;
-        beta_unit.d_ = 0;
-        T log_Q_fvar = log1m(gamma_p(alpha_unit, beta_unit));
+        T beta_y_unit = beta_y;
+        beta_y_unit.d_ = 0;
+        T log_Q_fvar = internal::log_q_gamma_cf(alpha_unit, beta_y_unit);
         out.dlogQ_dalpha = log_Q_fvar.d_;
-      } else {
-        out.dlogQ_dalpha = -grad_reg_lower_inc_gamma(alpha, beta_y) / exp(out.log_Q);
       }
     }
+  }
+
+  out.ok = std::isfinite(value_of_rec(out.log_Q));
+  return out;
+}
 
-    out.ok = true;
+/**
+ * Computes log q and d(log q) / d(alpha) using log1m.
+ */
+template <typename T, typename T_shape, bool partials_fvar>
+static inline Q_eval<T> eval_q_log1m(const T& alpha, const T& beta_y) {
+  Q_eval<T> out;
+  out.log_Q = log1m(gamma_p(alpha, beta_y));
+
+  if (!std::isfinite(value_of_rec(out.log_Q))) {
+    out.ok = false;
     return out;
   }
+
+  if constexpr (is_autodiff_v<T_shape>) {
+    if constexpr (partials_fvar) {
+      T alpha_unit = alpha;
+      alpha_unit.d_ = 1;
+      T beta_unit = beta_y;
+      beta_unit.d_ = 0;
+      T log_Q_fvar = log1m(gamma_p(alpha_unit, beta_unit));
+      out.dlogQ_dalpha = log_Q_fvar.d_;
+    } else {
+      out.dlogQ_dalpha
+          = -grad_reg_lower_inc_gamma(alpha, beta_y) / exp(out.log_Q);
+    }
+  }
+
+  out.ok = true;
+  return out;
 }
+}  // namespace internal
 
 template <typename T_y, typename T_shape, typename T_inv_scale>
-inline return_type_t<T_y, T_shape, T_inv_scale> gamma_lccdf(const T_y& y,
-                                                            const T_shape& alpha,
-                                                            const T_inv_scale& beta) {
+inline return_type_t<T_y, T_shape, T_inv_scale> gamma_lccdf(
+    const T_y& y, const T_shape& alpha, const T_inv_scale& beta) {
   using std::exp;
   using std::log;
   using T_partials_return = partials_return_t<T_y, T_shape, T_inv_scale>;
@@ -159,16 +156,17 @@ inline return_type_t<T_y, T_shape, T_inv_scale> gamma_lccdf(const T_y& y,
     const bool use_continued_fraction = beta_y > alpha_dbl + 1.0;
     internal::Q_eval<T_partials_return> result;
     if (use_continued_fraction) {
-      result = internal::eval_q_cf<T_partials_return, T_shape,
-                                any_fvar, partials_fvar>(alpha_dbl, beta_y);
-    } else {
-      result = internal::eval_q_log1m<T_partials_return, T_shape,
+      result = internal::eval_q_cf<T_partials_return, T_shape, any_fvar,
                                    partials_fvar>(alpha_dbl, beta_y);
+    } else {
+      result
+          = internal::eval_q_log1m<T_partials_return, T_shape, partials_fvar>(
+              alpha_dbl, beta_y);
 
       if (!result.ok && beta_y > 0.0) {
         // Fallback to continued fraction if log1m fails
-        result = internal::eval_q_cf<T_partials_return, T_shape,
-                                  any_fvar, partials_fvar>(alpha_dbl, beta_y);
+        result = internal::eval_q_cf<T_partials_return, T_shape, any_fvar,
+                                     partials_fvar>(alpha_dbl, beta_y);
       }
     }
     if (!result.ok) {
@@ -181,8 +179,9 @@ inline return_type_t<T_y, T_shape, T_inv_scale> gamma_lccdf(const T_y& y,
       const T_partials_return log_y = log(y_dbl);
       const T_partials_return alpha_minus_one = fma(alpha_dbl, log_y, -log_y);
 
-      const T_partials_return log_pdf
-        = alpha_dbl * log(beta_dbl) - lgamma(alpha_dbl) + alpha_minus_one - beta_y;
+      const T_partials_return log_pdf = alpha_dbl * log(beta_dbl)
+                                        - lgamma(alpha_dbl) + alpha_minus_one
+                                        - beta_y;
 
       const T_partials_return hazard = exp(log_pdf - result.log_Q);  // f/Q