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

Author: stan-buildbot

stan/math/prim/fun/size.hpp

@@ -34,7 +34,6 @@ inline int64_t size(const T& m) {
   return m.size();
 }
 
-
 template <typename T, require_tuple_t<T>* = nullptr>
 inline int64_t size(const T& /*t*/) {
   return std::tuple_size<std::remove_reference_t<T>>{};

stan/math/prim/fun/vector_seq_view.hpp

@@ -13,8 +13,7 @@ using is_matrix_or_std_vector_or_tuple
 
 template <typename T>
 using is_scalar_container = math::disjunction<
-    is_matrix<T>,
-    math::is_tuple<T>,
+    is_matrix<T>, math::is_tuple<T>,
     math::conjunction<is_std_vector<T>, is_stan_scalar<value_type_t<T>>>>;
 }  // namespace internal
 

stan/math/prim/prob/gaussian_copula_cholesky_lpdf.hpp

@@ -17,29 +17,25 @@ namespace math {
 namespace internal {
 
 template <typename Ty_elem, typename Ttuple, std::size_t... I>
-auto apply_lcdfs_elem_impl(
-  Ty_elem&& y_elem, Ttuple&& lcdf_tuple, std::index_sequence<I...>) {
+auto apply_lcdfs_elem_impl(Ty_elem&& y_elem, Ttuple&& lcdf_tuple,
+                           std::index_sequence<I...>) {
   auto&& lcdf_func = std::get<0>(lcdf_tuple);
-  return lcdf_func(
-    std::forward<Ty_elem>(y_elem),
-    std::get<I + 1>(std::forward<Ttuple>(lcdf_tuple))...
-  );
+  return lcdf_func(std::forward<Ty_elem>(y_elem),
+                   std::get<I + 1>(std::forward<Ttuple>(lcdf_tuple))...);
 }
 
 template <typename Ty, typename Ttuple>
 auto apply_lcdfs(Ty&& y, Ttuple&& lcdf_tuple) {
   return index_apply<std::tuple_size<std::remove_reference_t<Ttuple>>{}>(
-    [&y, &lcdf_tuple](auto... Is) {
-      return std::make_tuple(
-        apply_lcdfs_elem_impl(
-          y[Is], std::get<Is>(lcdf_tuple), std::make_index_sequence<
-            std::tuple_size<std::remove_reference_t<decltype(std::get<Is>(lcdf_tuple))>>{} - 1>{}
-        )...
-      );
-    });
-}
+      [&y, &lcdf_tuple](auto... Is) {
+        return std::make_tuple(apply_lcdfs_elem_impl(
+            y[Is], std::get<Is>(lcdf_tuple),
+            std::make_index_sequence<std::tuple_size<std::remove_reference_t<
+                                         decltype(std::get<Is>(lcdf_tuple))>>{}
+                                     - 1>{})...);
+      });
 }
-
+}  // namespace internal
 
 /** \ingroup multivar_dists
  * The log of the Gaussian copula density for the given y and
@@ -67,15 +63,17 @@ auto apply_lcdfs(Ty&& y, Ttuple&& lcdf_tuple) {
  * @tparam T_chol Type of cholesky factor.
  */
 template <bool propto, typename T_y, typename T_lcdf_fun_tuple, typename T_chol>
-auto gaussian_copula_cholesky_lpdf(
-  const T_y& y, const T_lcdf_fun_tuple& lcdf_fun_tuple, const T_chol chol) {
+auto gaussian_copula_cholesky_lpdf(const T_y& y,
+                                   const T_lcdf_fun_tuple& lcdf_fun_tuple,
+                                   const T_chol chol) {
   static constexpr const char* function = "gaussian_copula_cholesky_lpdf";
 
   using T_y_ref = ref_type_t<T_y>;
   using T_chol_ref = ref_type_t<T_chol>;
   using T_lcdf_ref = ref_type_t<T_lcdf_fun_tuple>;
 
-  check_consistent_sizes_mvt(function, "y", y, "lcdf_fun_tuple", lcdf_fun_tuple);
+  check_consistent_sizes_mvt(function, "y", y, "lcdf_fun_tuple",
+                             lcdf_fun_tuple);
   const size_t size_mvt_y = size_mvt(y);
   const size_t size_mvt_lcdf_tuple = size_mvt(lcdf_fun_tuple);
   T_y_ref y_ref = y;
@@ -84,7 +82,9 @@ auto gaussian_copula_cholesky_lpdf(
 
   vector_seq_view<T_y_ref> y_vec(y_ref);
   vector_seq_view<T_lcdf_ref> lcdf_tuple_vec(lcdf_tuple_ref);
-  using T_return = return_type_t<T_y, decltype(internal::apply_lcdfs(y_vec[0], lcdf_tuple_vec[0])), T_chol>;
+  using T_return = return_type_t<
+      T_y, decltype(internal::apply_lcdfs(y_vec[0], lcdf_tuple_vec[0])),
+      T_chol>;
 
   if (size_mvt_y == 0) {
     return T_return(0);
@@ -135,14 +135,14 @@ auto gaussian_copula_cholesky_lpdf(
     const auto& func_i = lcdf_tuple_vec[i];
 
     const auto& res = internal::apply_lcdfs(y_i, func_i);
-    const auto& u = index_apply<std::tuple_size<std::remove_reference_t<decltype(res)>>{}>(
-      [&res, size_y](auto... Is) {
-        Eigen::Matrix<T_return, Eigen::Dynamic, 1> u_inner(size_y);
-        static_cast<void>(std::initializer_list<int>{
-          (u_inner[Is] = std::get<Is>(res), 0)...
+    const auto& u = index_apply<
+        std::tuple_size<std::remove_reference_t<decltype(res)>>{}>(
+        [&res, size_y](auto... Is) {
+          Eigen::Matrix<T_return, Eigen::Dynamic, 1> u_inner(size_y);
+          static_cast<void>(std::initializer_list<int>{
+              (u_inner[Is] = std::get<Is>(res), 0)...});
+          return u_inner;
         });
-        return u_inner;
-      });
     check_bounded(function, "LCDF-transformed inputs", u, NEGATIVE_INFTY, 0);
     q[i] = std_normal_log_qf(u);
     lp -= std_normal_lpdf<propto>(q[i]);
@@ -153,8 +153,9 @@ auto gaussian_copula_cholesky_lpdf(
 }
 
 template <typename T_y, typename T_lcdf_fun_tuple, typename T_chol>
-auto gaussian_copula_cholesky_lpdf(
-  const T_y& y, const T_lcdf_fun_tuple& lcdf_fun_tuple, const T_chol chol) {
+auto gaussian_copula_cholesky_lpdf(const T_y& y,
+                                   const T_lcdf_fun_tuple& lcdf_fun_tuple,
+                                   const T_chol chol) {
   return gaussian_copula_cholesky_lpdf<false>(y, lcdf_fun_tuple, chol);
 }
 }  // namespace math

test/unit/math/mix/prob/gaussian_copula_cholesky_test.cpp

@@ -4,10 +4,8 @@ TEST_F(AgradRev, ProbDistributionsGaussCopulaCholesky) {
   // Bind functors for compatibility with AD framework
   auto f = [](const auto func1, const auto func2) {
     return [=](const auto& y, const auto& args, const auto& sigma) {
-      auto lcdf_functors = std::make_tuple(
-        std::make_tuple(func1, args[0]),
-        std::make_tuple(func2, args[1])
-      );
+      auto lcdf_functors = std::make_tuple(std::make_tuple(func1, args[0]),
+                                           std::make_tuple(func2, args[1]));
       auto sigma_sym = stan::math::multiply(0.5, sigma + sigma.transpose());
       auto L = stan::math::cholesky_decompose(sigma_sym);
       return stan::math::gaussian_copula_cholesky_lpdf(y, lcdf_functors, L);
@@ -24,9 +22,7 @@ TEST_F(AgradRev, ProbDistributionsGaussCopulaCholesky) {
   auto func1 = [](const auto& y, const auto& mu) {
     return stan::math::normal_lcdf(y, mu, 1.0);
   };
-  auto func2 = [](const auto& y) {
-    return stan::math::std_normal_lcdf(y);
-  };
+  auto func2 = [](const auto& y) { return stan::math::std_normal_lcdf(y); };
 
   Eigen::MatrixXd Sigma22(2, 2);
   Sigma22 << 2.0, 0.5, 0.5, 1.1;

test/unit/math/prim/prob/gaussian_copula_cholesky_lpdf_test.cpp

@@ -2,9 +2,9 @@
 #include <gtest/gtest.h>
 
 TEST(ProbDistributionsGaussianCopulaCholesky, EqualsMultiNormalCholesky) {
+  using stan::math::diag_pre_multiply;
   using stan::math::gaussian_copula_cholesky_lpdf;
   using stan::math::multi_normal_cholesky_lpdf;
-  using stan::math::diag_pre_multiply;
 
   Eigen::VectorXd y(2);
   y << 1, 3;
@@ -22,25 +22,19 @@ TEST(ProbDistributionsGaussianCopulaCholesky, EqualsMultiNormalCholesky) {
     return stan::math::normal_lcdf(y, mu, sigma);
   };
 
-  auto std_norm_lcdf = [](auto&& y) {
-    return stan::math::std_normal_lcdf(y);
-  };
+  auto std_norm_lcdf = [](auto&& y) { return stan::math::std_normal_lcdf(y); };
 
   // y[0] ~ normal(0.1, 2)
   // y[1] ~ normal(0, 1)
-  auto lcdf_functors = std::make_tuple(
-    std::make_tuple(norm_lcdf, mu[0], sd[0]),
-    std::make_tuple(std_norm_lcdf)
-  );
-
-  double log_prob =
-    stan::math::normal_lpdf(y[0], 0.1, 2) +
-    stan::math::std_normal_lpdf(y[1]) +
-    gaussian_copula_cholesky_lpdf(y, lcdf_functors, chol);
+  auto lcdf_functors = std::make_tuple(std::make_tuple(norm_lcdf, mu[0], sd[0]),
+                                       std::make_tuple(std_norm_lcdf));
 
+  double log_prob = stan::math::normal_lpdf(y[0], 0.1, 2)
+                    + stan::math::std_normal_lpdf(y[1])
+                    + gaussian_copula_cholesky_lpdf(y, lcdf_functors, chol);
 
-  double expected_log_prob = multi_normal_cholesky_lpdf(
-    y, mu, diag_pre_multiply(sd, chol));
+  double expected_log_prob
+      = multi_normal_cholesky_lpdf(y, mu, diag_pre_multiply(sd, chol));
 
   EXPECT_FLOAT_EQ(log_prob, expected_log_prob);
 }
@@ -62,15 +56,13 @@ TEST(ProbDistributionsGaussianCopulaCholesky, NonNormalMarginals) {
 
   // y[0] ~ gamma(2, 1)
   // y[1] ~ exponential(2)
-  auto lcdf_functors = std::make_tuple(
-    std::make_tuple(gamma_lcdf, 2.0, 1.0),
-    std::make_tuple(exp_lcdf, 2.0)
-  );
+  auto lcdf_functors = std::make_tuple(std::make_tuple(gamma_lcdf, 2.0, 1.0),
+                                       std::make_tuple(exp_lcdf, 2.0));
 
-  double log_prob =
-    stan::math::gamma_lpdf(y[0], 2.0, 1.0) +
-    stan::math::exponential_lpdf(y[1], 2.0) +
-    stan::math::gaussian_copula_cholesky_lpdf(y, lcdf_functors, chol);
+  double log_prob
+      = stan::math::gamma_lpdf(y[0], 2.0, 1.0)
+        + stan::math::exponential_lpdf(y[1], 2.0)
+        + stan::math::gaussian_copula_cholesky_lpdf(y, lcdf_functors, chol);
 
   EXPECT_FLOAT_EQ(log_prob, -16.61005941);
 }
@@ -92,32 +84,25 @@ TEST(ProbDistributionsGaussianCopulaCholesky, Errors) {
     return stan::math::exponential_lcdf(y, scale);
   };
 
-  auto lcdf_functors = std::make_tuple(
-    std::make_tuple(gamma_lcdf, 2.0, 1.0),
-    std::make_tuple(exp_lcdf, 2.0)
-  );
+  auto lcdf_functors = std::make_tuple(std::make_tuple(gamma_lcdf, 2.0, 1.0),
+                                       std::make_tuple(exp_lcdf, 2.0));
 
-  auto small_lcdf_functors = std::make_tuple(
-    std::make_tuple(gamma_lcdf, 2.0, 1.0)
-  );
+  auto small_lcdf_functors
+      = std::make_tuple(std::make_tuple(gamma_lcdf, 2.0, 1.0));
 
-  auto invalid_lcdf_functors = std::make_tuple(
-    std::make_tuple(gamma_lcdf, 2.0, 1.0),
-    std::make_tuple([](auto&& y){ return y * 10; })
-  );
+  auto invalid_lcdf_functors
+      = std::make_tuple(std::make_tuple(gamma_lcdf, 2.0, 1.0),
+                        std::make_tuple([](auto&& y) { return y * 10; }));
 
   EXPECT_THROW(
-    stan::math::gaussian_copula_cholesky_lpdf(y, small_lcdf_functors, chol),
-    std::invalid_argument
-  );
+      stan::math::gaussian_copula_cholesky_lpdf(y, small_lcdf_functors, chol),
+      std::invalid_argument);
 
   EXPECT_THROW(
-    stan::math::gaussian_copula_cholesky_lpdf(small_y, lcdf_functors, chol),
-    std::invalid_argument
-  );
+      stan::math::gaussian_copula_cholesky_lpdf(small_y, lcdf_functors, chol),
+      std::invalid_argument);
 
   EXPECT_THROW(
-    stan::math::gaussian_copula_cholesky_lpdf(y, invalid_lcdf_functors, chol),
-    std::domain_error
-  );
+      stan::math::gaussian_copula_cholesky_lpdf(y, invalid_lcdf_functors, chol),
+      std::domain_error);
 }