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

Author: stan-buildbot

stan/math/fwd/fun/multiply.hpp

@@ -22,7 +22,8 @@ inline auto multiply(Mat1&& m1, Mat2&& m2) {
   decltype(auto) m1_ref = to_ref(m1);
   decltype(auto) m2_ref = to_ref(m2);
   return to_fvar(multiply(m1_ref.val(), m2_ref.val()),
-                 add(multiply(m1_ref.val(), m2_ref.d()), multiply(m1_ref.d(), m2_ref.val())));
+                 add(multiply(m1_ref.val(), m2_ref.d()),
+                     multiply(m1_ref.d(), m2_ref.val())));
 }
 
 template <typename Mat1, typename Mat2,

stan/math/fwd/fun/quad_form_sym.hpp

@@ -35,10 +35,11 @@ inline promote_scalar_t<return_type_t<EigMat1, EigMat2>, EigMat2> quad_form_sym(
   check_symmetric("quad_form_sym", "A", A_ref);
   decltype(auto) B_ref = to_ref(std::forward<EigMat2>(B));
   promote_scalar_t<T_ret, plain_type_t<EigMat2>> ret(
-      multiply(B_ref.transpose(), multiply(std::forward<decltype(A_ref)>(A_ref), B_ref)));
-  return make_holder([](auto&& ret) {
-    return T_ret(0.5) * (ret + ret.transpose());
-  }, std::move(ret));
+      multiply(B_ref.transpose(),
+               multiply(std::forward<decltype(A_ref)>(A_ref), B_ref)));
+  return make_holder(
+      [](auto&& ret) { return T_ret(0.5) * (ret + ret.transpose()); },
+      std::move(ret));
 }
 
 /**
@@ -61,9 +62,13 @@ inline return_type_t<EigMat, ColVec> quad_form_sym(EigMat&& A, ColVec&& B) {
   decltype(auto) A_ref = to_ref(std::forward<EigMat>(A));
   check_symmetric("quad_form_sym", "A", A_ref);
   decltype(auto) B_ref = to_ref(std::forward<ColVec>(B));
-  return make_holder([](auto&& B_ref_, auto&& A_ref_) {
-    return dot_product(B_ref_, multiply(std::forward<decltype(A_ref_)>(A_ref_), B_ref_));
-  }, std::forward<decltype(B_ref)>(B_ref), std::forward<decltype(A_ref)>(A_ref));
+  return make_holder(
+      [](auto&& B_ref_, auto&& A_ref_) {
+        return dot_product(
+            B_ref_, multiply(std::forward<decltype(A_ref_)>(A_ref_), B_ref_));
+      },
+      std::forward<decltype(B_ref)>(B_ref),
+      std::forward<decltype(A_ref)>(A_ref));
 }
 
 }  // namespace math

stan/math/prim/constraint/corr_matrix_constrain.hpp

@@ -44,7 +44,8 @@ corr_matrix_constrain(T&& x, Eigen::Index k) {
   decltype(auto) x_ref = to_ref(std::forward<T>(x));
   check_size_match("cov_matrix_constrain", "x.size()", x_ref.size(),
                    "k_choose_2", k_choose_2);
-  decltype(auto) cpc_ref = to_ref(corr_constrain(std::forward<decltype(x_ref)>(x_ref)));
+  decltype(auto) cpc_ref
+      = to_ref(corr_constrain(std::forward<decltype(x_ref)>(x_ref)));
   return read_corr_matrix(cpc_ref, k);
 }
 
@@ -78,7 +79,8 @@ corr_matrix_constrain(T&& x, Eigen::Index k, Lp& lp) {
   decltype(auto) x_ref = to_ref(std::forward<T>(x));
   check_size_match("cov_matrix_constrain", "x.size()", x_ref.size(),
                    "k_choose_2", k_choose_2);
-  decltype(auto) cpc_ref = to_ref(corr_constrain(std::forward<decltype(x_ref)>(x_ref), lp));
+  decltype(auto) cpc_ref
+      = to_ref(corr_constrain(std::forward<decltype(x_ref)>(x_ref), lp));
   return read_corr_matrix(cpc_ref, k, lp);
 }
 

stan/math/prim/fun/add.hpp

@@ -42,9 +42,8 @@ template <typename Mat1, typename Mat2,
           require_all_not_st_var<Mat1, Mat2>* = nullptr>
 inline auto add(Mat1&& m1, Mat2&& m2) {
   check_matching_dims("add", "m1", m1, "m2", m2);
-  return make_holder([](auto&& m1_, auto&& m2_) {
-    return m1_ + m2_;
-  }, std::forward<Mat1>(m1), std::forward<Mat2>(m2));
+  return make_holder([](auto&& m1_, auto&& m2_) { return m1_ + m2_; },
+                     std::forward<Mat1>(m1), std::forward<Mat2>(m2));
 }
 
 /**
@@ -60,9 +59,8 @@ template <typename Mat, typename Scal, require_eigen_t<Mat>* = nullptr,
           require_stan_scalar_t<Scal>* = nullptr,
           require_all_not_st_var<Mat, Scal>* = nullptr>
 inline auto add(Mat&& m, const Scal c) {
-  return make_holder([c](auto&& m_) {
-    return (m_.array() + c).matrix();
-  }, std::forward<Mat>(m));
+  return make_holder([c](auto&& m_) { return (m_.array() + c).matrix(); },
+                     std::forward<Mat>(m));
 }
 
 /**
@@ -78,9 +76,8 @@ template <typename Scal, typename Mat, require_stan_scalar_t<Scal>* = nullptr,
           require_eigen_t<Mat>* = nullptr,
           require_all_not_st_var<Scal, Mat>* = nullptr>
 inline auto add(const Scal c, Mat&& m) {
-  return make_holder([c](auto&& m_) {
-    return (c + m_.array()).matrix();
-  }, std::forward<Mat>(m));
+  return make_holder([c](auto&& m_) { return (c + m_.array()).matrix(); },
+                     std::forward<Mat>(m));
 }
 
 }  // namespace math

stan/math/prim/fun/all.hpp

@@ -35,9 +35,8 @@ constexpr inline bool all(T x) {
 template <typename ContainerT,
           require_eigen_st<std::is_integral, ContainerT>* = nullptr>
 inline bool all(ContainerT&& x) {
-  return make_holder([](auto&& x_) {
-    return x_.all();
-  }, std::forward<ContainerT>(x));
+  return make_holder([](auto&& x_) { return x_.all(); },
+                     std::forward<ContainerT>(x));
 }
 
 // Forward-declaration for correct resolution of all(std::vector<std::tuple>)

stan/math/prim/fun/any.hpp

@@ -35,9 +35,8 @@ constexpr inline bool any(T x) {
 template <typename ContainerT,
           require_eigen_st<std::is_integral, ContainerT>* = nullptr>
 inline bool any(ContainerT&& x) {
-  return make_holder([](auto&& x_) {
-    return x_.any();
-  }, std::forward<ContainerT>(x));
+  return make_holder([](auto&& x_) { return x_.any(); },
+                     std::forward<ContainerT>(x));
 }
 
 // Forward-declaration for correct resolution of any(std::vector<std::tuple>)

stan/math/prim/fun/block.hpp

@@ -24,9 +24,11 @@ inline auto block(T&& m, size_t i, size_t j, size_t nrows, size_t ncols) {
   check_row_index("block", "i+nrows-1", m, i + nrows - 1);
   check_column_index("block", "j", m, j);
   check_column_index("block", "j+ncols-1", m, j + ncols - 1);
-  return make_holder([i, j, nrows, ncols](auto&& m_) {
-    return m_.block(i - 1, j - 1, nrows, ncols);
-  }, std::forward<T>(m));
+  return make_holder(
+      [i, j, nrows, ncols](auto&& m_) {
+        return m_.block(i - 1, j - 1, nrows, ncols);
+      },
+      std::forward<T>(m));
 }
 
 }  // namespace math

stan/math/prim/fun/chol2inv.hpp

@@ -35,7 +35,8 @@ inline plain_type_t<T> chol2inv(T&& L) {
     X.coeffRef(0) = inv_square(L_ref.coeff(0, 0));
     return X;
   }
-  return crossprod(mdivide_left_tri<Eigen::Lower>(std::forward<decltype(L_ref)>(L_ref)));
+  return crossprod(
+      mdivide_left_tri<Eigen::Lower>(std::forward<decltype(L_ref)>(L_ref)));
 }
 
 }  // namespace math

stan/math/prim/fun/col.hpp

@@ -24,9 +24,8 @@ namespace math {
 template <typename T, require_matrix_t<T>* = nullptr>
 inline auto col(T&& m, size_t j) {
   check_column_index("col", "j", m, j);
-  return make_holder([j](auto&& m_) {
-    return m_.col(j - 1);
-  }, std::forward<T>(m));
+  return make_holder([j](auto&& m_) { return m_.col(j - 1); },
+                     std::forward<T>(m));
 }
 
 }  // namespace math

stan/math/prim/fun/columns_dot_product.hpp

@@ -26,9 +26,11 @@ template <typename Mat1, typename Mat2,
           require_all_not_eigen_vt<is_var, Mat1, Mat2>* = nullptr>
 inline auto columns_dot_product(Mat1&& v1, Mat2&& v2) {
   check_matching_dims("columns_dot_product", "v1", v1, "v2", v2);
-  return make_holder([](auto&& v1_, auto&& v2_) {
-    return v1_.cwiseProduct(v2_).colwise().sum();
-  }, to_ref(std::forward<Mat1>(v1)), to_ref(std::forward<Mat2>(v2)));
+  return make_holder(
+      [](auto&& v1_, auto&& v2_) {
+        return v1_.cwiseProduct(v2_).colwise().sum();
+      },
+      to_ref(std::forward<Mat1>(v1)), to_ref(std::forward<Mat2>(v2)));
 }
 
 }  // namespace math