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

stan/math/rev/fun/atan2.hpp

@@ -103,61 +103,64 @@ template <typename Mat1, typename Mat2,
 inline auto atan2(Mat1&& a, Mat2&& b) {
   arena_t<Mat1> arena_a = std::forward<Mat1>(a);
   arena_t<Mat2> arena_b = std::forward<Mat2>(b);
-    auto a_sq_plus_b_sq
-        = to_arena(value_of(arena_a).array().square()
-                   + value_of(arena_b).array().square());
-    return make_callback_var(
-        atan2(arena_a.val(), arena_b.val()),
-        [arena_a, arena_b, a_sq_plus_b_sq](auto& vi) mutable {
-          if constexpr (is_autodiffable_v<Mat1>) {
-            arena_a.adj().array()
-                += vi.adj().array() * value_of(arena_b).array() / a_sq_plus_b_sq;
-          }
-          if constexpr (is_autodiffable_v<Mat2>) {
-            arena_b.adj().array()
-                += -vi.adj().array() * value_of(arena_a).array() / a_sq_plus_b_sq;
-          }
-        });
+  auto a_sq_plus_b_sq = to_arena(value_of(arena_a).array().square()
+                                 + value_of(arena_b).array().square());
+  return make_callback_var(
+      atan2(arena_a.val(), arena_b.val()),
+      [arena_a, arena_b, a_sq_plus_b_sq](auto& vi) mutable {
+        if constexpr (is_autodiffable_v<Mat1>) {
+          arena_a.adj().array()
+              += vi.adj().array() * value_of(arena_b).array() / a_sq_plus_b_sq;
+        }
+        if constexpr (is_autodiffable_v<Mat2>) {
+          arena_b.adj().array()
+              += -vi.adj().array() * value_of(arena_a).array() / a_sq_plus_b_sq;
+        }
+      });
 }
 
 template <typename Scalar, typename VarMat,
           require_var_matrix_t<VarMat>* = nullptr,
           require_stan_scalar_t<Scalar>* = nullptr>
 inline auto atan2(Scalar a, VarMat&& b) {
   arena_t<VarMat> arena_b = std::forward<VarMat>(b);
-  auto a_sq_plus_b_sq = to_arena(
-      square(value_of(a)) + (value_of(arena_b).array().square()));
-    return make_callback_var(
-        atan2(value_of(a), value_of(arena_b)),
-        [a, arena_b, a_sq_plus_b_sq](auto& vi) mutable {
-          if constexpr (is_autodiffable_v<Scalar>) {
-            a.adj() += (vi.adj().array() * value_of(arena_b).array() / a_sq_plus_b_sq)
-                          .sum();
-          }
-          if constexpr (is_autodiffable_v<VarMat>) {
-            arena_b.adj().array() += -vi.adj().array() * value_of(a) / a_sq_plus_b_sq;
-          }
-        });
+  auto a_sq_plus_b_sq
+      = to_arena(square(value_of(a)) + (value_of(arena_b).array().square()));
+  return make_callback_var(
+      atan2(value_of(a), value_of(arena_b)),
+      [a, arena_b, a_sq_plus_b_sq](auto& vi) mutable {
+        if constexpr (is_autodiffable_v<Scalar>) {
+          a.adj()
+              += (vi.adj().array() * value_of(arena_b).array() / a_sq_plus_b_sq)
+                     .sum();
+        }
+        if constexpr (is_autodiffable_v<VarMat>) {
+          arena_b.adj().array()
+              += -vi.adj().array() * value_of(a) / a_sq_plus_b_sq;
+        }
+      });
 }
 
 template <typename VarMat, typename Scalar,
           require_var_matrix_t<VarMat>* = nullptr,
           require_stan_scalar_t<Scalar>* = nullptr>
 inline auto atan2(VarMat&& a, Scalar b) {
   arena_t<VarMat> arena_a = std::forward<VarMat>(a);
-  auto a_sq_plus_b_sq = to_arena(value_of(arena_a).array().square() + square(value_of(b)));
-    return make_callback_var(
-        atan2(value_of(arena_a), value_of(b)),
-        [arena_a, b, a_sq_plus_b_sq](auto& vi) mutable {
+  auto a_sq_plus_b_sq
+      = to_arena(value_of(arena_a).array().square() + square(value_of(b)));
+  return make_callback_var(
+      atan2(value_of(arena_a), value_of(b)),
+      [arena_a, b, a_sq_plus_b_sq](auto& vi) mutable {
         if constexpr (is_autodiffable_v<VarMat>) {
-          arena_a.adj().array() += vi.adj().array() * value_of(b) / a_sq_plus_b_sq;
+          arena_a.adj().array()
+              += vi.adj().array() * value_of(b) / a_sq_plus_b_sq;
         }
         if constexpr (is_autodiffable_v<Scalar>) {
-          b.adj()
-              += -(vi.adj().array() * value_of(arena_a).array() / a_sq_plus_b_sq)
-                      .sum();
+          b.adj() += -(vi.adj().array() * value_of(arena_a).array()
+                       / a_sq_plus_b_sq)
+                          .sum();
         }
-        });
+      });
 }
 
 }  // namespace math

stan/math/rev/fun/columns_dot_product.hpp

@@ -36,7 +36,9 @@ inline auto columns_dot_product(Mat1&& v1, Mat2&& v2) {
   arena_t<Mat1> arena_v1 = std::forward<Mat1>(v1);
   arena_t<Mat2> arena_v2 = std::forward<Mat2>(v2);
   arena_t<return_t> res
-        = (value_of(arena_v1).array() * value_of(arena_v2).array()).colwise().sum();
+      = (value_of(arena_v1).array() * value_of(arena_v2).array())
+            .colwise()
+            .sum();
   reverse_pass_callback([arena_v1, arena_v2, res]() mutable {
     if constexpr (is_autodiffable_v<Mat1>) {
       if constexpr (is_var_matrix<Mat1>::value) {

stan/math/rev/fun/fma.hpp

@@ -205,10 +205,12 @@ inline auto fma_reverse_pass(T1& arena_x, T2& arena_y, T3& arena_z, T4& ret) {
     auto&& y_arr = as_array_or_scalar(arena_y);
     auto&& z_arr = as_array_or_scalar(arena_z);
     if constexpr (!is_constant_v<T1>) {
-      x_arr.adj() += conditional_sum<is_stan_scalar_v<T1>>(ret.adj().array() * value_of(y_arr));
+      x_arr.adj() += conditional_sum<is_stan_scalar_v<T1>>(ret.adj().array()
+                                                           * value_of(y_arr));
     }
     if constexpr (!is_constant_v<T2>) {
-      y_arr.adj() += conditional_sum<is_stan_scalar_v<T2>>(ret.adj().array() * value_of(x_arr));
+      y_arr.adj() += conditional_sum<is_stan_scalar_v<T2>>(ret.adj().array()
+                                                           * value_of(x_arr));
     }
     if constexpr (!is_constant_v<T3>) {
       z_arr.adj() += conditional_sum<is_stan_scalar_v<T3>>(ret.adj().array());

stan/math/rev/fun/mdivide_left_spd.hpp

@@ -26,9 +26,9 @@ namespace math {
  * @throws std::domain_error if A is not square or B does not have
  * as many rows as A has columns.
  */
-template <typename T1, typename T2, require_all_matrix_t<T1, T2> * = nullptr,
-  require_any_st_var<T1, T2>* = nullptr>
-inline auto mdivide_left_spd(T1 &&A, T2 &&B) {
+template <typename T1, typename T2, require_all_matrix_t<T1, T2>* = nullptr,
+          require_any_st_var<T1, T2>* = nullptr>
+inline auto mdivide_left_spd(T1&& A, T2&& B) {
   using ret_val_type = plain_type_t<decltype(value_of(A) * value_of(B))>;
   using ret_type = return_var_matrix_t<ret_val_type, T1, T2>;
   if (A.size() == 0) {

stan/math/rev/fun/mdivide_left_tri.hpp

@@ -27,7 +27,7 @@ namespace math {
  * as many rows as A has columns.
  */
 template <Eigen::UpLoType TriView, typename T1, typename T2,
-          require_all_matrix_t<T1, T2> * = nullptr,
+          require_all_matrix_t<T1, T2>* = nullptr,
           require_any_st_var<T1, T2>* = nullptr>
 inline auto mdivide_left_tri(T1&& A, T2&& B) {
   using ret_val_type = plain_type_t<decltype(value_of(A) * value_of(B))>;
@@ -59,17 +59,20 @@ inline auto mdivide_left_tri(T1&& A, T2&& B) {
     arena_t<ret_type> res
         = arena_A_val.template triangularView<TriView>().solve(B);
     reverse_pass_callback([arena_A, arena_A_val, res]() mutable {
-      arena_A.adj() -= (arena_A_val.template triangularView<TriView>().transpose().solve(
-              res.adj()) * res.val().transpose().eval())
-                           .template triangularView<TriView>();
+      arena_A.adj()
+          -= (arena_A_val.template triangularView<TriView>().transpose().solve(
+                  res.adj())
+              * res.val().transpose().eval())
+                 .template triangularView<TriView>();
     });
     return res;
   } else {
     arena_t<T2> arena_B = std::forward<T2>(B);
     arena_t<ret_type> res
         = arena_A.template triangularView<TriView>().solve(arena_B.val());
     reverse_pass_callback([arena_A, arena_B, res]() mutable {
-      arena_B.adj() += arena_A.template triangularView<TriView>().transpose().solve(
+      arena_B.adj()
+          += arena_A.template triangularView<TriView>().transpose().solve(
               res.adj());
     });
     return res;