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

Author: stan-buildbot

stan/math/rev/fun/beta.hpp

@@ -179,10 +179,9 @@ inline auto beta(const Scalar& a, const VarMat& b) {
     auto digamma_ab = to_arena((digamma(arena_b.val()).array()
                                 - digamma(arena_a + arena_b.val().array()))
                                * beta_val.array());
-    return make_callback_var(
-        beta_val, [arena_b, digamma_ab](auto& vi) mutable {
-          arena_b.adj().array() += vi.adj().array() * digamma_ab.array();
-        });
+    return make_callback_var(beta_val, [arena_b, digamma_ab](auto& vi) mutable {
+      arena_b.adj().array() += vi.adj().array() * digamma_ab.array();
+    });
   }
 }
 
@@ -209,12 +208,11 @@ inline auto beta(const VarMat& a, const Scalar& b) {
     double arena_b = value_of(b);
     auto digamma_ab = to_arena(digamma(arena_a.val()).array()
                                - digamma(arena_a.val().array() + arena_b));
-    return make_callback_var(beta(arena_a.val(), arena_b),
-                             [arena_a, digamma_ab](auto& vi) mutable {
-                               arena_a.adj().array() += vi.adj().array()
-                                                        * digamma_ab
-                                                        * vi.val().array();
-                             });
+    return make_callback_var(
+        beta(arena_a.val(), arena_b), [arena_a, digamma_ab](auto& vi) mutable {
+          arena_a.adj().array()
+              += vi.adj().array() * digamma_ab * vi.val().array();
+        });
   } else if (!is_constant<Scalar>::value) {
     arena_t<promote_scalar_t<double, VarMat>> arena_a = value_of(a);
     var arena_b = b;

stan/math/rev/fun/lub_constrain.hpp

@@ -320,15 +320,14 @@ inline auto lub_constrain(const T& x, const L& lb, const U& ub,
     auto diff = to_arena(ub_val - lb_val);
     auto neg_abs_x = to_arena(-arena_x_val.abs());
     auto inv_logit_x = to_arena(inv_logit(arena_x_val));
-    arena_t<ret_type> ret = (is_lb_inf).select(
-        ub_val - arena_x_val.exp(), diff * inv_logit_x + lb_val);
+    arena_t<ret_type> ret = (is_lb_inf).select(ub_val - arena_x_val.exp(),
+                                               diff * inv_logit_x + lb_val);
     lp += (is_lb_inf)
               .select(arena_x_val,
                       log(diff) + (neg_abs_x - (2.0 * log1p_exp(neg_abs_x))))
               .sum();
-    reverse_pass_callback(
-      [arena_x, arena_x_val, ub, arena_lb, ret, lp, diff, inv_logit_x,
-                           is_lb_inf]() mutable {
+    reverse_pass_callback([arena_x, arena_x_val, ub, arena_lb, ret, lp, diff,
+                           inv_logit_x, is_lb_inf]() mutable {
       using T_var = arena_t<promote_scalar_t<var, T>>;
       using L_var = arena_t<promote_scalar_t<var, L>>;
       const auto lp_adj = lp.adj();

stan/math/rev/fun/svd_U.hpp

@@ -52,8 +52,8 @@ inline auto svd_U(const EigMat& m) {
   arena_t<ret_type> arena_U = svd.matrixU();
   auto arena_V = to_arena(svd.matrixV());
 
-  reverse_pass_callback(
-    [arena_m, arena_U, arena_D, arena_V, arena_Fp]() mutable {
+  reverse_pass_callback([arena_m, arena_U, arena_D, arena_V,
+                         arena_Fp]() mutable {
     Eigen::MatrixXd UUadjT = arena_U.val_op().transpose() * arena_U.adj_op();
     arena_m.adj()
         += .5 * arena_U.val_op()

stan/math/rev/fun/svd_V.hpp

@@ -52,8 +52,8 @@ inline auto svd_V(const EigMat& m) {
   auto arena_U = to_arena(svd.matrixU());
   arena_t<ret_type> arena_V = svd.matrixV();
 
-  reverse_pass_callback(
-    [arena_m, arena_U, arena_D, arena_V, arena_Fm]() mutable {
+  reverse_pass_callback([arena_m, arena_U, arena_D, arena_V,
+                         arena_Fm]() mutable {
     Eigen::MatrixXd VTVadj = arena_V.val_op().transpose() * arena_V.adj_op();
     arena_m.adj()
         += 0.5 * arena_U

test/unit/math/test_ad_matvar.hpp

@@ -968,9 +968,9 @@ void expect_ad_vectorized_matvar(const ad_tolerances& tols, const F& f,
   std::vector<decltype(y_vec)> y_stdvec_vec{y_vec, y_vec};
   std::vector<std::vector<T1>> x_stdvec_stdvec{x_stdvec, x_stdvec};
   std::vector<std::vector<T2>> y_stdvec_stdvec{y_stdvec, y_stdvec};
-  expect_ad_matvar(tols, f, x_scal, y);                 // scal, mat
-  expect_ad_matvar(tols, f, x_scal, y_vec);             // scal, mat
-  expect_ad_matvar(tols, f, x_scal, y_stdvec);          // scal, nest<mat>
+  expect_ad_matvar(tols, f, x_scal, y);               // scal, mat
+  expect_ad_matvar(tols, f, x_scal, y_vec);           // scal, mat
+  expect_ad_matvar(tols, f, x_scal, y_stdvec);        // scal, nest<mat>
   expect_ad_matvar(tols, f, x, y_vec);                // stdvec, vec
   expect_ad_matvar(tols, f, x_stdvec, y_stdvec_vec);  // nest<stdvec>, nest<vec>
   expect_ad_matvar(tols, f, x_stdvec, y);             // nest<stdvec>, mat