[Jenkins] auto-formatting by clang-format version 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

Author: stan-buildbot

stan/math/prim/fun/bessel_first_kind.hpp

@@ -52,7 +52,7 @@ inline T2 bessel_first_kind(int v, const T2 z) {
  * @return Bessel first kind function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
- require_not_var_matrix_t<T2>* = nullptr>
+          require_not_var_matrix_t<T2>* = nullptr>
 inline auto bessel_first_kind(const T1& a, const T2& b) {
   return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
     return bessel_first_kind(c, d);

stan/math/prim/fun/beta.hpp

@@ -66,7 +66,7 @@ inline return_type_t<T1, T2> beta(const T1 a, const T2 b) {
  * @return Beta function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
- require_all_not_var_matrix_t<T1, T2>* = nullptr>
+          require_all_not_var_matrix_t<T1, T2>* = nullptr>
 inline auto beta(const T1& a, const T2& b) {
   return apply_scalar_binary(
       a, b, [&](const auto& c, const auto& d) { return beta(c, d); });

stan/math/prim/fun/binary_log_loss.hpp

@@ -43,7 +43,7 @@ inline T binary_log_loss(int y, const T& y_hat) {
  * @return Binary log loss function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
- require_not_var_matrix_t<T2>* = nullptr>
+          require_not_var_matrix_t<T2>* = nullptr>
 inline auto binary_log_loss(const T1& a, const T2& b) {
   return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
     return binary_log_loss(c, d);

stan/math/prim/fun/erf.hpp

@@ -31,9 +31,10 @@ struct erf_fun {
  * @param x container
  * @return Error function applied to each value in x.
  */
-template <typename T, require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-                          T>* = nullptr,
-                          require_not_var_matrix_t<T>* = nullptr>
+template <
+    typename T,
+    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+    require_not_var_matrix_t<T>* = nullptr>
 inline auto erf(const T& x) {
   return apply_scalar_unary<erf_fun, T>::apply(x);
 }

stan/math/prim/fun/erfc.hpp

@@ -32,9 +32,10 @@ struct erfc_fun {
  * @param x container
  * @return Complementary error function applied to each value in x.
  */
-template <typename T, require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-                          T>* = nullptr,
-                          require_not_var_matrix_t<T>* = nullptr>
+template <
+    typename T,
+    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+    require_not_var_matrix_t<T>* = nullptr>
 inline auto erfc(const T& x) {
   return apply_scalar_unary<erfc_fun, T>::apply(x);
 }

stan/math/prim/fun/exp2.hpp

@@ -35,9 +35,10 @@ struct exp2_fun {
  * @param x container
  * @return Elementwise exp2 of members of container.
  */
-template <typename T, require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-                          T>* = nullptr,
-                          require_not_var_matrix_t<T>* = nullptr>
+template <
+    typename T,
+    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+    require_not_var_matrix_t<T>* = nullptr>
 inline auto exp2(const T& x) {
   return apply_scalar_unary<exp2_fun, T>::apply(x);
 }

stan/math/prim/fun/expm1.hpp

@@ -32,9 +32,10 @@ struct expm1_fun {
  * @param x container
  * @return Natural exponential of each value in x minus one.
  */
-template <typename T, require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-                          T>* = nullptr,
-                          require_not_var_matrix_t<T>* = nullptr>
+template <
+    typename T,
+    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+    require_not_var_matrix_t<T>* = nullptr>
 inline auto expm1(const T& x) {
   return apply_scalar_unary<expm1_fun, T>::apply(x);
 }

stan/math/prim/fun/falling_factorial.hpp

@@ -79,7 +79,7 @@ inline return_type_t<T> falling_factorial(const T& x, int n) {
  * @return Falling factorial function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
- require_all_not_var_matrix_t<T1, T2>* = nullptr>
+          require_all_not_var_matrix_t<T1, T2>* = nullptr>
 inline auto falling_factorial(const T1& a, const T2& b) {
   return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
     return falling_factorial(c, d);

stan/math/prim/fun/floor.hpp

@@ -37,7 +37,7 @@ template <typename Container,
           require_not_container_st<std::is_arithmetic, Container>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               Container>* = nullptr,
-              require_not_var_matrix_t<Container>* = nullptr>
+          require_not_var_matrix_t<Container>* = nullptr>
 inline auto floor(const Container& x) {
   return apply_scalar_unary<floor_fun, Container>::apply(x);
 }

stan/math/rev/fun/bessel_first_kind.hpp

@@ -21,24 +21,26 @@ inline var bessel_first_kind(int v, const var& a) {
 template <typename T, require_eigen_t<T>* = nullptr>
 inline auto bessel_first_kind(int v, const var_value<T>& a) {
   auto ret_val = bessel_first_kind(v, a.val()).array().eval();
-  auto precomp_bessel
-      = to_arena(v * ret_val / a.val().array() - bessel_first_kind(v + 1, a.val()).array());
-  return make_callback_var(ret_val.matrix(),
-                           [precomp_bessel, a](const auto& vi) mutable {
-                             a.adj().array() += vi.adj().array() * precomp_bessel;
-                           });
+  auto precomp_bessel = to_arena(v * ret_val / a.val().array()
+                                 - bessel_first_kind(v + 1, a.val()).array());
+  return make_callback_var(
+      ret_val.matrix(), [precomp_bessel, a](const auto& vi) mutable {
+        a.adj().array() += vi.adj().array() * precomp_bessel;
+      });
 }
 
 template <typename T, require_eigen_t<T>* = nullptr>
-inline auto bessel_first_kind(const std::vector<int>& v, const var_value<T>& a) {
+inline auto bessel_first_kind(const std::vector<int>& v,
+                              const var_value<T>& a) {
   auto ret_val = bessel_first_kind(v, a.val()).array().eval();
   Eigen::Map<const Eigen::Array<int, -1, 1>> v_map(v.data(), v.size());
   auto precomp_bessel
-      = to_arena(v_map.template cast<double>() * ret_val / a.val().array() - bessel_first_kind(v_map + 1, a.val().array()));
-  return make_callback_var(ret_val.matrix(),
-                           [precomp_bessel, a](const auto& vi) mutable {
-                             a.adj().array() += vi.adj().array() * precomp_bessel;
-                           });
+      = to_arena(v_map.template cast<double>() * ret_val / a.val().array()
+                 - bessel_first_kind(v_map + 1, a.val().array()));
+  return make_callback_var(
+      ret_val.matrix(), [precomp_bessel, a](const auto& vi) mutable {
+        a.adj().array() += vi.adj().array() * precomp_bessel;
+      });
 }
 
 }  // namespace math