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

Author: stan-buildbot

stan/math/opencl/prim/binomial_logit_glm_lpmf.hpp

@@ -24,9 +24,8 @@
 namespace stan {
 namespace math {
 
-template <bool propto, typename T_n_cl, typename T_N_cl,
-          typename T_x_cl, typename T_alpha_cl,
-          typename T_beta_cl,
+template <bool propto, typename T_n_cl, typename T_N_cl, typename T_x_cl,
+          typename T_alpha_cl, typename T_beta_cl,
           require_all_prim_or_rev_kernel_expression_t<
               T_n_cl, T_N_cl, T_x_cl, T_alpha_cl, T_beta_cl>* = nullptr>
 return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> binomial_logit_glm_lpmf(
@@ -37,8 +36,8 @@ return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> binomial_logit_glm_lpmf(
   constexpr bool is_y_vector = !is_stan_scalar<T_n_cl>::value;
   constexpr bool is_alpha_vector = !is_stan_scalar<T_alpha_cl>::value;
 
-  const size_t N_instances = max(max_size(n, N, alpha),
-                                  static_cast<size_t>(x.rows()));
+  const size_t N_instances
+      = max(max_size(n, N, alpha), static_cast<size_t>(x.rows()));
   const size_t N_attributes = x.cols();
 
   check_consistent_sizes(function, "Successes variable", n,
@@ -76,26 +75,26 @@ return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> binomial_logit_glm_lpmf(
       = static_select<include_summand<propto, T_n_cl, T_N_cl>::value>(
           logp_expr1 + binomial_coefficient_log(N, n), logp_expr1);
 
-  constexpr bool need_theta_deriv =
-    !is_constant_all<T_beta_cl, T_x_cl, T_alpha_cl>::value;
+  constexpr bool need_theta_deriv
+      = !is_constant_all<T_beta_cl, T_x_cl, T_alpha_cl>::value;
   auto theta_deriv_expr = n - elt_multiply(N, exp(log_inv_logit_theta));
 
   constexpr bool need_theta_deriv_sum = need_theta_deriv && !is_alpha_vector;
   matrix_cl<double> logp_cl;
   matrix_cl<double> theta_deriv_cl;
   matrix_cl<double> theta_deriv_sum_cl;
 
-  results(check_n_bounded, check_N_nonnegative, logp_cl,
-          theta_deriv_cl, theta_deriv_sum_cl) = expressions(
-      n_bounded, N_nonnegative, logp_expr,
-      calc_if<need_theta_deriv>(theta_deriv_expr),
-      calc_if<need_theta_deriv_sum>(colwise_sum(theta_deriv_expr)));
+  results(check_n_bounded, check_N_nonnegative, logp_cl, theta_deriv_cl,
+          theta_deriv_sum_cl)
+      = expressions(
+          n_bounded, N_nonnegative, logp_expr,
+          calc_if<need_theta_deriv>(theta_deriv_expr),
+          calc_if<need_theta_deriv_sum>(colwise_sum(theta_deriv_expr)));
 
   T_partials_return logp = sum(from_matrix_cl(logp_cl));
   using std::isfinite;
   if (!isfinite(logp)) {
-    check_cl(function, "Intercept", alpha_val, "finite")
-        = isfinite(alpha_val);
+    check_cl(function, "Intercept", alpha_val, "finite") = isfinite(alpha_val);
     check_cl(function, "Weight vector", beta_val, "finite")
         = isfinite(beta_val);
     check_cl(function, "Matrix of independent variables", x_val, "finite")
@@ -104,8 +103,7 @@ return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> binomial_logit_glm_lpmf(
 
   auto ops_partials = make_partials_propagator(x, alpha, beta);
   if (!is_constant_all<T_x_cl>::value) {
-    partials<0>(ops_partials)
-        = transpose(beta_val * transpose(theta_deriv_cl));
+    partials<0>(ops_partials) = transpose(beta_val * transpose(theta_deriv_cl));
   }
   if (!is_constant_all<T_alpha_cl>::value) {
     if (is_alpha_vector) {

test/unit/math/opencl/rev/binomial_logit_glm_lpmf_test.cpp

@@ -6,8 +6,8 @@
 #include <vector>
 
 TEST(ProbDistributionsBinomialLogitGLM, error_checking) {
-  using stan::math::matrix_cl;
   using stan::math::binomial_logit_glm_lpmf;
+  using stan::math::matrix_cl;
 
   int N = 3;
   int M = 2;
@@ -80,10 +80,10 @@ TEST(ProbDistributionsBinomialLogitGLM, error_checking) {
       binomial_logit_glm_lpmf(n_cl, trials_cl, x_cl, alpha_cl, beta_size_cl),
       std::invalid_argument);
 
-   EXPECT_THROW(
+  EXPECT_THROW(
       binomial_logit_glm_lpmf(n_value_cl, trials_cl, x_cl, alpha_cl, beta_cl),
       std::domain_error);
-   EXPECT_THROW(
+  EXPECT_THROW(
       binomial_logit_glm_lpmf(n_cl, trials_value_cl, x_cl, alpha_cl, beta_cl),
       std::domain_error);
   EXPECT_THROW(
@@ -98,15 +98,15 @@ TEST(ProbDistributionsBinomialLogitGLM, error_checking) {
 }
 
 auto binomial_logit_glm_lpmf_functor
-    = [](const auto& n, const auto& trials, const auto& x,
-          const auto& alpha, const auto& beta) {
+    = [](const auto& n, const auto& trials, const auto& x, const auto& alpha,
+         const auto& beta) {
         return stan::math::binomial_logit_glm_lpmf(n, trials, x, alpha, beta);
       };
 auto binomial_logit_glm_lpmf_functor_propto
-    = [](const auto& n, const auto& trials, const auto& x,
-          const auto& alpha, const auto& beta) {
-        return stan::math::binomial_logit_glm_lpmf<true>(n, trials, x,
-                                                          alpha, beta);
+    = [](const auto& n, const auto& trials, const auto& x, const auto& alpha,
+         const auto& beta) {
+        return stan::math::binomial_logit_glm_lpmf<true>(n, trials, x, alpha,
+                                                         beta);
       };
 
 TEST(ProbDistributionsBinomialLogitGLM, opencl_matches_cpu_small_simple) {
@@ -121,8 +121,8 @@ TEST(ProbDistributionsBinomialLogitGLM, opencl_matches_cpu_small_simple) {
   beta << 0.3, 2;
   double alpha = 0.3;
 
-  stan::math::test::compare_cpu_opencl_prim_rev(
-      binomial_logit_glm_lpmf_functor, n, trials, x, alpha, beta);
+  stan::math::test::compare_cpu_opencl_prim_rev(binomial_logit_glm_lpmf_functor,
+                                                n, trials, x, alpha, beta);
   stan::math::test::compare_cpu_opencl_prim_rev(
       binomial_logit_glm_lpmf_functor_propto, n, trials, x, alpha, beta);
 }
@@ -156,8 +156,8 @@ TEST(ProbDistributionsBinomialLogitGLM, opencl_matches_cpu_zero_instances) {
   beta << 0.3, 2;
   double alpha = 0.3;
 
-  stan::math::test::compare_cpu_opencl_prim_rev(
-      binomial_logit_glm_lpmf_functor, n, trials, x, alpha, beta);
+  stan::math::test::compare_cpu_opencl_prim_rev(binomial_logit_glm_lpmf_functor,
+                                                n, trials, x, alpha, beta);
   stan::math::test::compare_cpu_opencl_prim_rev(
       binomial_logit_glm_lpmf_functor_propto, n, trials, x, alpha, beta);
 }
@@ -172,15 +172,13 @@ TEST(ProbDistributionsBinomialLogitGLM, opencl_matches_cpu_zero_attributes) {
   Eigen::VectorXd beta(M);
   double alpha = 0.3;
 
-  stan::math::test::compare_cpu_opencl_prim_rev(
-      binomial_logit_glm_lpmf_functor, n, trials, x, alpha, beta);
+  stan::math::test::compare_cpu_opencl_prim_rev(binomial_logit_glm_lpmf_functor,
+                                                n, trials, x, alpha, beta);
   stan::math::test::compare_cpu_opencl_prim_rev(
       binomial_logit_glm_lpmf_functor_propto, n, trials, x, alpha, beta);
 }
 
-
-TEST(ProbDistributionsBinomialLogitGLM,
-     opencl_matches_cpu_small_vector_alpha) {
+TEST(ProbDistributionsBinomialLogitGLM, opencl_matches_cpu_small_vector_alpha) {
   int N = 3;
   int M = 2;
 
@@ -193,8 +191,8 @@ TEST(ProbDistributionsBinomialLogitGLM,
   Eigen::VectorXd alpha(N);
   alpha << 0.3, -0.8, 1.8;
 
-  stan::math::test::compare_cpu_opencl_prim_rev(
-      binomial_logit_glm_lpmf_functor, n, trials, x, alpha, beta);
+  stan::math::test::compare_cpu_opencl_prim_rev(binomial_logit_glm_lpmf_functor,
+                                                n, trials, x, alpha, beta);
   stan::math::test::compare_cpu_opencl_prim_rev(
       binomial_logit_glm_lpmf_functor_propto, n, trials, x, alpha, beta);
 }
@@ -213,8 +211,8 @@ TEST(ProbDistributionsBinomialLogitGLM, opencl_matches_cpu_big) {
   Eigen::VectorXd beta = Eigen::VectorXd::Random(M);
   Eigen::VectorXd alpha = Eigen::VectorXd::Random(N);
 
-  stan::math::test::compare_cpu_opencl_prim_rev(
-      binomial_logit_glm_lpmf_functor, n, trials, x, alpha, beta);
+  stan::math::test::compare_cpu_opencl_prim_rev(binomial_logit_glm_lpmf_functor,
+                                                n, trials, x, alpha, beta);
   stan::math::test::compare_cpu_opencl_prim_rev(
       binomial_logit_glm_lpmf_functor_propto, n, trials, x, alpha, beta);
 }