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

Author: stan-buildbot

stan/math/prim/fun/select.hpp

@@ -142,11 +142,14 @@ template <typename T_bool, typename T_true, typename T_false,
           require_all_stan_scalar_t<T_true, T_false>* = nullptr>
 inline auto select(T_bool&& c, const T_true& y_true, const T_false& y_false) {
   using ret_t = return_type_t<T_true, T_false>;
-  return make_holder([y_true, y_false](auto&& c_) {
-      return std::forward<decltype(c_)>(c_).unaryExpr([y_true, y_false](bool cond) {
-        return cond ? ret_t(y_true) : ret_t(y_false);
-      });
-  }, std::forward<T_bool>(c));
+  return make_holder(
+      [y_true, y_false](auto&& c_) {
+        return std::forward<decltype(c_)>(c_).unaryExpr(
+            [y_true, y_false](bool cond) {
+              return cond ? ret_t(y_true) : ret_t(y_false);
+            });
+      },
+      std::forward<T_bool>(c));
 }
 
 /**
@@ -169,17 +172,25 @@ inline auto select(T_bool&& c, T_true&& y_true, T_false&& y_false) {
                          "right hand side", y_false);
   using ret_t = return_type_t<T_true, T_false>;
   if constexpr (!std::is_same_v<std::decay_t<T_true>, std::decay_t<T_false>>) {
-    return make_holder([](auto&& c_, auto&& y_true_, auto&& y_false_) {
-      return std::forward<decltype(c_)>(c_).select(
-          std::forward<decltype(y_true_)>(y_true_),
-          std::forward<decltype(y_false_)>(y_false_));
-    }, std::forward<T_bool>(c), std::forward<T_true>(y_true), std::forward<T_false>(y_false));
+    return make_holder(
+        [](auto&& c_, auto&& y_true_, auto&& y_false_) {
+          return std::forward<decltype(c_)>(c_).select(
+              std::forward<decltype(y_true_)>(y_true_),
+              std::forward<decltype(y_false_)>(y_false_));
+        },
+        std::forward<T_bool>(c), std::forward<T_true>(y_true),
+        std::forward<T_false>(y_false));
   } else {
-    return make_holder([](auto&& c_, auto&& y_true_, auto&& y_false_) {
-      return std::forward<decltype(c_)>(c_).select(std::forward<decltype(y_true_)>(y_true_),
-                                    std::forward<decltype(y_false_)>(y_false_)).template cast<ret_t>();
-    }, std::forward<T_bool>(c), std::forward<T_true>(y_true), std::forward<T_false>(y_false));
-}
+    return make_holder(
+        [](auto&& c_, auto&& y_true_, auto&& y_false_) {
+          return std::forward<decltype(c_)>(c_)
+              .select(std::forward<decltype(y_true_)>(y_true_),
+                      std::forward<decltype(y_false_)>(y_false_))
+              .template cast<ret_t>();
+        },
+        std::forward<T_bool>(c), std::forward<T_true>(y_true),
+        std::forward<T_false>(y_false));
+  }
 }
 }  // namespace math
 }  // namespace stan

stan/math/prim/prob/neg_binomial_2_lpmf.hpp

@@ -61,31 +61,34 @@ inline return_type_t<T_location, T_precision> neg_binomial_2_lpmf(
   auto mu_plus_phi = mu_val + phi_val;
   auto log_mu_plus_phi = log(mu_plus_phi);
   auto n_plus_phi = value_of(n_vec) + phi_val;
-  constexpr bool include_precision = include_summand<propto, T_precision>::value;
+  constexpr bool include_precision
+      = include_summand<propto, T_precision>::value;
   constexpr bool include_location = include_summand<propto, T_location>::value;
   auto logp_calc = [&]() {
     return -phi_val * (log1p(mu_val / phi_val))
-          - value_of(n_vec) * log_mu_plus_phi;
+           - value_of(n_vec) * log_mu_plus_phi;
   };
   if constexpr (include_precision || include_location) {
     if constexpr (include_precision && include_location) {
-      logp += sum(binomial_coefficient_log(n_plus_phi - 1, n_vec) + multiply_log(n_vec, mu_val) + logp_calc());
+      logp += sum(binomial_coefficient_log(n_plus_phi - 1, n_vec)
+                  + multiply_log(n_vec, mu_val) + logp_calc());
     } else if constexpr (include_precision) {
-      logp += sum(binomial_coefficient_log(n_plus_phi - 1, n_vec) + logp_calc());
+      logp
+          += sum(binomial_coefficient_log(n_plus_phi - 1, n_vec) + logp_calc());
     } else if constexpr (include_location) {
       logp += sum(multiply_log(n_vec, mu_val) + logp_calc());
     }
   }
   if constexpr (is_autodiff_v<T_location>) {
-    partials<0>(ops_partials) = n_vec / mu_val - (n_vec + phi_val) / mu_plus_phi;
+    partials<0>(ops_partials)
+        = n_vec / mu_val - (n_vec + phi_val) / mu_plus_phi;
   }
   if constexpr (is_autodiff_v<T_precision>) {
-    auto log_term
-        = select(mu_val < phi_val, log1p(-mu_val / mu_plus_phi),
-                 log_phi - log_mu_plus_phi);
+    auto log_term = select(mu_val < phi_val, log1p(-mu_val / mu_plus_phi),
+                           log_phi - log_mu_plus_phi);
     partials<1>(ops_partials) = (mu_val - value_of(n_vec)) / mu_plus_phi
-                                    + log_term - digamma(phi_val)
-                                    + digamma(n_plus_phi);
+                                + log_term - digamma(phi_val)
+                                + digamma(n_plus_phi);
   }
   return ops_partials.build(logp);
 }