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

Author: stan-buildbot

stan/math/mix/functor/laplace_likelihood.hpp

@@ -9,7 +9,7 @@ namespace stan {
 namespace math {
 
 namespace internal {
-    /**
+/**
  * Set all adjoints of the output to zero.
  */
 template <typename Output>
@@ -43,8 +43,7 @@ inline void set_zero_adjoint(Output&& output) {
   }
 }
 
-}
-
+}  // namespace internal
 
 /**
  * functions to compute the log density, first, second,
@@ -160,8 +159,7 @@ inline auto shallow_copy_vargs(Args&&... args) {
  */
 template <typename F, typename Theta, typename Stream, typename... Args,
           require_eigen_vector_vt<std::is_arithmetic, Theta>* = nullptr>
-inline auto theta_grad(F&& f, Theta&& theta,
-                 Stream* msgs, Args&&... args) {
+inline auto theta_grad(F&& f, Theta&& theta, Stream* msgs, Args&&... args) {
   using Eigen::Dynamic;
   using Eigen::Matrix;
   nested_rev_autodiff nested;
@@ -186,16 +184,14 @@ inline auto theta_grad(F&& f, Theta&& theta,
  */
 template <typename F, typename Theta, typename Stream, typename... Args,
           require_eigen_vector_vt<std::is_arithmetic, Theta>* = nullptr>
-inline void ll_arg_grad(F&& f, Theta&& theta,
-                 Stream* msgs, Args&&... args) {
+inline void ll_arg_grad(F&& f, Theta&& theta, Stream* msgs, Args&&... args) {
   using Eigen::Dynamic;
   using Eigen::Matrix;
   nested_rev_autodiff nested;
   var f_var = f(theta, args..., msgs);
   grad(f_var.vi_);
 }
 
-
 /**
  * Computes negative block diagonal Hessian of `f` wrt`theta` and `args...`
  * @note If `Args` contains \ref var types then their adjoints will be
@@ -214,14 +210,15 @@ inline void ll_arg_grad(F&& f, Theta&& theta,
  */
 template <typename F, typename Theta, typename Stream, typename... Args,
           require_eigen_vector_vt<std::is_arithmetic, Theta>* = nullptr>
-inline auto diagonal_hessian(F&& f, Theta&& theta, Stream* msgs, Args&&... args) {
+inline auto diagonal_hessian(F&& f, Theta&& theta, Stream* msgs,
+                             Args&&... args) {
   using Eigen::Dynamic;
   using Eigen::Matrix;
   const Eigen::Index theta_size = theta.size();
   auto v = Eigen::VectorXd::Ones(theta_size);
   Eigen::VectorXd hessian_v = Eigen::VectorXd::Zero(theta_size);
   hessian_times_vector(f, hessian_v, std::forward<Theta>(theta), std::move(v),
-                        value_of(args)..., msgs);
+                       value_of(args)..., msgs);
   return (-hessian_v).eval();
 }
 
@@ -243,8 +240,9 @@ inline auto diagonal_hessian(F&& f, Theta&& theta, Stream* msgs, Args&&... args)
  */
 template <typename F, typename Theta, typename Stream, typename... Args,
           require_eigen_vector_vt<std::is_arithmetic, Theta>* = nullptr>
-inline auto block_hessian(F&& f, Theta&& theta, const Eigen::Index hessian_block_size,
-                 Stream* msgs, Args&&... args) {
+inline auto block_hessian(F&& f, Theta&& theta,
+                          const Eigen::Index hessian_block_size, Stream* msgs,
+                          Args&&... args) {
   using Eigen::Dynamic;
   using Eigen::Matrix;
   const Eigen::Index theta_size = theta.size();
@@ -260,12 +258,12 @@ inline auto block_hessian(F&& f, Theta&& theta, const Eigen::Index hessian_block
     }
     return (-hessian_theta).eval();
   } else {
-    return (-hessian_block_diag(f, std::forward<Theta>(theta), hessian_block_size,
-                             value_of(args)..., msgs)).eval();
+    return (-hessian_block_diag(f, std::forward<Theta>(theta),
+                                hessian_block_size, value_of(args)..., msgs))
+        .eval();
   }
 }
 
-
 /**
  * Computes theta gradient and negative block diagonal Hessian of `f` wrt
  * `theta` and `args...`
@@ -476,28 +474,27 @@ template <typename F, typename Theta, typename TupleArgs, typename Stream,
           require_eigen_vector_t<Theta>* = nullptr,
           require_tuple_t<TupleArgs>* = nullptr>
 inline auto theta_grad(F&& f, Theta&& theta, TupleArgs&& ll_tup,
-                           Stream* msgs = nullptr) {
+                       Stream* msgs = nullptr) {
   return apply(
       [](auto&& f, auto&& theta, auto&& msgs, auto&&... args) {
-        return internal::theta_grad(
-            std::forward<decltype(f)>(f), std::forward<decltype(theta)>(theta),
-            msgs, std::forward<decltype(args)>(args)...);
+        return internal::theta_grad(std::forward<decltype(f)>(f),
+                                    std::forward<decltype(theta)>(theta), msgs,
+                                    std::forward<decltype(args)>(args)...);
       },
       std::forward<TupleArgs>(ll_tup), std::forward<F>(f),
       std::forward<Theta>(theta), msgs);
 }
 
-
 template <typename F, typename Theta, typename TupleArgs, typename Stream,
           require_eigen_vector_t<Theta>* = nullptr,
           require_tuple_t<TupleArgs>* = nullptr>
 inline auto ll_arg_grad(F&& f, Theta&& theta, TupleArgs&& ll_tup,
-                           Stream* msgs = nullptr) {
+                        Stream* msgs = nullptr) {
   return apply(
       [](auto&& f, auto&& theta, auto&& msgs, auto&&... args) {
-        return internal::ll_arg_grad(
-            std::forward<decltype(f)>(f), std::forward<decltype(theta)>(theta),
-            msgs, std::forward<decltype(args)>(args)...);
+        return internal::ll_arg_grad(std::forward<decltype(f)>(f),
+                                     std::forward<decltype(theta)>(theta), msgs,
+                                     std::forward<decltype(args)>(args)...);
       },
       std::forward<TupleArgs>(ll_tup), std::forward<F>(f),
       std::forward<Theta>(theta), msgs);
@@ -506,10 +503,10 @@ inline auto ll_arg_grad(F&& f, Theta&& theta, TupleArgs&& ll_tup,
 template <typename F, typename Theta, typename TupleArgs, typename Stream,
           require_eigen_vector_t<Theta>* = nullptr,
           require_tuple_t<TupleArgs>* = nullptr>
-inline auto diagonal_hessian(F&& f, Theta&& theta, TupleArgs&& ll_tuple, Stream* msgs) {
+inline auto diagonal_hessian(F&& f, Theta&& theta, TupleArgs&& ll_tuple,
+                             Stream* msgs) {
   return apply(
-      [](auto&& f, auto&& theta, auto* msgs,
-         auto&&... args) {
+      [](auto&& f, auto&& theta, auto* msgs, auto&&... args) {
         return internal::diagonal_hessian(
             std::forward<decltype(f)>(f), std::forward<decltype(theta)>(theta),
             msgs, std::forward<decltype(args)>(args)...);
@@ -521,8 +518,9 @@ inline auto diagonal_hessian(F&& f, Theta&& theta, TupleArgs&& ll_tuple, Stream*
 template <typename F, typename Theta, typename TupleArgs, typename Stream,
           require_eigen_vector_t<Theta>* = nullptr,
           require_tuple_t<TupleArgs>* = nullptr>
-inline auto block_hessian(F&& f, Theta&& theta, const Eigen::Index hessian_block_size,
-                 TupleArgs&& ll_tuple, Stream* msgs) {
+inline auto block_hessian(F&& f, Theta&& theta,
+                          const Eigen::Index hessian_block_size,
+                          TupleArgs&& ll_tuple, Stream* msgs) {
   return apply(
       [](auto&& f, auto&& theta, auto hessian_block_size, auto* msgs,
          auto&&... args) {

stan/math/mix/functor/wolfe_line_search.hpp

@@ -590,16 +590,17 @@ struct WolfeInfo {
  * 6. **Convergence/guard rails.**
  *    After each evaluation we check:
  *    - Gradient tolerance: \f$|\phi'(\alpha)| \le
- *      \max(\text{opt.abs\_grad\_threshold},\ \text{opt.rel\_grad\_threshold}\,|\phi'(0)|)\f$.
+ *      \max(\text{opt.abs\_grad\_threshold},\
+ * \text{opt.rel\_grad\_threshold}\,|\phi'(0)|)\f$.
  *    - Objective change tolerance (for very small steps):
  *      \f$|\phi(\alpha)-\phi(0)| \le
- *      \max(\text{opt.abs\_obj\_threshold},\ \text{opt.rel\_obj\_threshold}\,(1+|\phi(0)|))\f$
- *      and \f$\alpha < \text{opt.min_alpha}\f$.
- *    If triggered, the routine returns one of `ConvergedGradient`,
- *    `ConvergedObjective`, or `ConvergedObjectiveAndGradient`.
- *    If neither test is met but the bracket becomes too small, it returns
- *    `IntervalTooSmall` (accepting the current point only if it satisfies
- * Armijo).
+ *      \max(\text{opt.abs\_obj\_threshold},\
+ * \text{opt.rel\_obj\_threshold}\,(1+|\phi(0)|))\f$ and \f$\alpha <
+ * \text{opt.min_alpha}\f$. If triggered, the routine returns one of
+ * `ConvergedGradient`, `ConvergedObjective`, or
+ * `ConvergedObjectiveAndGradient`. If neither test is met but the bracket
+ * becomes too small, it returns `IntervalTooSmall` (accepting the current point
+ * only if it satisfies Armijo).
  *
  * If zoom exits without a strong-Wolfe point but an Armijo-OK point was seen,
  * the routine **returns** `Armijo` at that best point; otherwise it **returns**

stan/math/mix/prob/laplace_latent_bernoulli_logit_rng.hpp

@@ -39,10 +39,10 @@ inline Eigen::VectorXd laplace_latent_tol_bernoulli_logit_rng(
     const double tolerance, const int max_num_steps,
     const int hessian_block_size, const int solver,
     const int max_steps_line_search, RNG& rng, std::ostream* msgs) {
-  laplace_options_user_supplied ops{hessian_block_size,    solver,
-                                    max_steps_line_search, tolerance,
-                                    max_num_steps, laplace_line_search_options{}, 
-                                    value_of(theta_0)};
+  laplace_options_user_supplied ops{
+      hessian_block_size, solver,        max_steps_line_search,
+      tolerance,          max_num_steps, laplace_line_search_options{},
+      value_of(theta_0)};
   return laplace_base_rng(
       bernoulli_logit_likelihood{},
       std::forward_as_tuple(to_vector(y), n_samples, std::forward<Mean>(mean)),

stan/math/mix/prob/laplace_latent_neg_binomial_2_log_rng.hpp

@@ -44,10 +44,13 @@ inline Eigen::VectorXd laplace_latent_tol_neg_binomial_2_log_rng(
     ThetaVec&& theta_0, const double tolerance, const int max_num_steps,
     const int hessian_block_size, const int solver,
     const int max_steps_line_search, RNG& rng, std::ostream* msgs) {
-  laplace_options_user_supplied ops{hessian_block_size,    solver,
-                                    tolerance,
-                                    max_num_steps, laplace_line_search_options{max_steps_line_search},
-                                    value_of(theta_0)};
+  laplace_options_user_supplied ops{
+      hessian_block_size,
+      solver,
+      tolerance,
+      max_num_steps,
+      laplace_line_search_options{max_steps_line_search},
+      value_of(theta_0)};
   return laplace_base_rng(
       neg_binomial_2_log_likelihood{},
       std::forward_as_tuple(std::forward<Eta>(eta), y, y_index,

stan/math/mix/prob/laplace_latent_poisson_log_rng.hpp

@@ -39,10 +39,13 @@ inline Eigen::VectorXd laplace_latent_tol_poisson_log_rng(
     const double tolerance, const int max_num_steps,
     const int hessian_block_size, const int solver,
     const int max_steps_line_search, RNG& rng, std::ostream* msgs) {
-  laplace_options_user_supplied ops{hessian_block_size,    solver,
-                                    tolerance,
-                                    max_num_steps, laplace_line_search_options{max_steps_line_search},
-                                    value_of(theta_0)};
+  laplace_options_user_supplied ops{
+      hessian_block_size,
+      solver,
+      tolerance,
+      max_num_steps,
+      laplace_line_search_options{max_steps_line_search},
+      value_of(theta_0)};
   return laplace_base_rng(
       poisson_log_likelihood{},
       std::forward_as_tuple(y, y_index, std::forward<Mean>(mean)),

stan/math/mix/prob/laplace_latent_rng.hpp

@@ -37,9 +37,12 @@ inline auto laplace_latent_tol_rng(
     const int max_num_steps, const int hessian_block_size, const int solver,
     const int max_steps_line_search, RNG& rng, std::ostream* msgs) {
   const laplace_options_user_supplied ops{
-      hessian_block_size, solver,
-      tolerance, max_num_steps,
-      laplace_line_search_options{max_steps_line_search}, value_of(theta_0)};
+      hessian_block_size,
+      solver,
+      tolerance,
+      max_num_steps,
+      laplace_line_search_options{max_steps_line_search},
+      value_of(theta_0)};
   return laplace_base_rng(std::forward<LLFunc>(L_f),
                           std::forward<LLArgs>(ll_args),
                           std::forward<CovarFun>(covariance_function),

stan/math/mix/prob/laplace_marginal.hpp

@@ -33,10 +33,13 @@ inline auto laplace_marginal_tol(
     CovarArgs&& covar_args, const ThetaVec& theta_0, double tolerance,
     int max_num_steps, const int hessian_block_size, const int solver,
     const int max_steps_line_search, std::ostream* msgs) {
-  laplace_options_user_supplied ops{hessian_block_size,    solver,
-                                    tolerance,
-                                    max_num_steps, laplace_line_search_options{max_steps_line_search},
-                                    value_of(theta_0)};
+  laplace_options_user_supplied ops{
+      hessian_block_size,
+      solver,
+      tolerance,
+      max_num_steps,
+      laplace_line_search_options{max_steps_line_search},
+      value_of(theta_0)};
   return laplace_marginal_density(
       std::forward<LFun>(L_f), std::forward<LArgs>(l_args),
       std::forward<CovarFun>(covariance_function),

stan/math/mix/prob/laplace_marginal_bernoulli_logit_lpmf.hpp

@@ -27,9 +27,8 @@ struct bernoulli_logit_likelihood {
                          const std::vector<int>& delta_int, Mean&& mean,
                          std::ostream* pstream) const {
     auto theta_offset = to_ref(add(theta, mean));
-    return sum(
-        elt_multiply(theta_offset, y)
-        - elt_multiply(to_vector(delta_int), log1p_exp(theta_offset)));
+    return sum(elt_multiply(theta_offset, y)
+               - elt_multiply(to_vector(delta_int), log1p_exp(theta_offset)));
   }
 };
 
@@ -62,10 +61,13 @@ inline auto laplace_marginal_tol_bernoulli_logit_lpmf(
     const ThetaVec& theta_0, double tolerance, int max_num_steps,
     const int hessian_block_size, const int solver,
     const int max_steps_line_search, std::ostream* msgs) {
-  laplace_options_user_supplied ops{hessian_block_size,    solver,
-                                    tolerance,
-                                    max_num_steps, laplace_line_search_options{max_steps_line_search},
-                                    value_of(theta_0)};
+  laplace_options_user_supplied ops{
+      hessian_block_size,
+      solver,
+      tolerance,
+      max_num_steps,
+      laplace_line_search_options{max_steps_line_search},
+      value_of(theta_0)};
   return laplace_marginal_density(
       bernoulli_logit_likelihood{},
       std::forward_as_tuple(to_vector(y), n_samples, std::forward<Mean>(mean)),

stan/math/mix/prob/laplace_marginal_neg_binomial_2_log_lpmf.hpp

@@ -42,11 +42,11 @@ struct neg_binomial_2_log_likelihood {
     Eigen::Map<const Eigen::VectorXi> y_map(y.data(), y.size());
 
     auto theta_offset = add(theta, mean);
-    auto log_eta      = log(eta);
+    auto log_eta = log(eta);
     auto lse = to_ref(log_sum_exp(theta_offset, log_eta));
 
     return sum(binomial_coefficient_log(subtract(add(y_map, eta), 1.0), y_map))
-         + sum(add(
+           + sum(add(
                // counts_per_group * (theta - log(eta + exp(theta)))
                elt_multiply(counts_per_group, subtract(theta_offset, lse)),
                // n_per_group * eta * (log(eta) - log(eta + exp(theta)))
@@ -85,10 +85,13 @@ inline auto laplace_marginal_tol_neg_binomial_2_log_lpmf(
     const ThetaVec& theta_0, double tolerance, int max_num_steps,
     const int hessian_block_size, const int solver,
     const int max_steps_line_search, std::ostream* msgs) {
-  laplace_options_user_supplied ops{hessian_block_size,    solver,
-                                    tolerance,
-                                    max_num_steps, laplace_line_search_options{max_steps_line_search},
-                                    value_of(theta_0)};
+  laplace_options_user_supplied ops{
+      hessian_block_size,
+      solver,
+      tolerance,
+      max_num_steps,
+      laplace_line_search_options{max_steps_line_search},
+      value_of(theta_0)};
   return laplace_marginal_density(
       neg_binomial_2_log_likelihood{},
       std::forward_as_tuple(eta, y, y_index, std::forward<Mean>(mean)),
@@ -142,11 +145,11 @@ struct neg_binomial_2_log_likelihood_summary {
         counts_per_group.data(), counts_per_group.size());
 
     auto theta_offset = add(theta, mean);
-    auto log_eta      = log(eta);
+    auto log_eta = log(eta);
     auto lse = to_ref(log_sum_exp(theta_offset, log_eta));
 
     return sum(binomial_coefficient_log(subtract(add(y_map, eta), 1.0), y_map))
-         + sum(add(
+           + sum(add(
                // counts_per_group * (theta - log(eta + exp(theta)))
                elt_multiply(counts_per_group_map, subtract(theta_offset, lse)),
                // n_per_group * eta * (log(eta) - log(eta + exp(theta)))
@@ -186,10 +189,13 @@ inline auto laplace_marginal_tol_neg_binomial_2_log_summary_lpmf(
     const ThetaVec& theta_0, double tolerance, int max_num_steps,
     const int hessian_block_size, const int solver,
     const int max_steps_line_search, std::ostream* msgs) {
-  laplace_options_user_supplied ops{hessian_block_size,    solver,
-                                    tolerance,
-                                    max_num_steps, laplace_line_search_options{max_steps_line_search},
-                                    value_of(theta_0)};
+  laplace_options_user_supplied ops{
+      hessian_block_size,
+      solver,
+      tolerance,
+      max_num_steps,
+      laplace_line_search_options{max_steps_line_search},
+      value_of(theta_0)};
   return laplace_marginal_density(
       neg_binomial_2_log_likelihood_summary{},
       std::forward_as_tuple(eta, y, n_per_group, counts_per_group,

stan/math/mix/prob/laplace_marginal_poisson_log_lpmf.hpp

@@ -77,10 +77,13 @@ inline auto laplace_marginal_tol_poisson_log_lpmf(
     const ThetaVec& theta_0, double tolerance, int max_num_steps,
     const int hessian_block_size, const int solver,
     const int max_steps_line_search, std::ostream* msgs) {
-  laplace_options_user_supplied ops{hessian_block_size,    solver,
-                                    tolerance,
-                                    max_num_steps, laplace_line_search_options{max_steps_line_search},
-                                    value_of(theta_0)};
+  laplace_options_user_supplied ops{
+      hessian_block_size,
+      solver,
+      tolerance,
+      max_num_steps,
+      laplace_line_search_options{max_steps_line_search},
+      value_of(theta_0)};
   return laplace_marginal_density(
       poisson_log_likelihood{},
       std::forward_as_tuple(y, y_index, std::forward<Mean>(mean)),