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

Author: stan-buildbot

stan/math/mix/functor/laplace_marginal_density_estimator.hpp

@@ -29,7 +29,7 @@ namespace math {
  */
 struct laplace_options_base {
   /* Size of the blocks in block diagonal hessian*/
-  int hessian_block_size{1}; // 0
+  int hessian_block_size{1};  // 0
   /**
    * Which linear solver to use inside the Newton step.
    *
@@ -45,19 +45,19 @@ struct laplace_options_base {
    *    `Sigma = K_root * K_root^T` and form `B = I + K_root^T * W * K_root`.
    * 3. General LU: form `B = I + Sigma * W` and factorize with LU.
    */
-  int solver{1}; // 1
+  int solver{1};  // 1
   /**
    * Iterations end when the absolute change in the optimization objective
    * is less than this tolerance.
    *
    * Note: the objective used for convergence is the one optimized by the
    * Newton/Wolfe loop (not the final Laplace-corrected log marginal density).
    */
-  double tolerance{1.49012e-08}; // 2
+  double tolerance{1.49012e-08};  // 2
   /* Maximum number of steps*/
-  int max_num_steps{500}; //3
-  int allow_fallthrough{true}; // 4
-  laplace_line_search_options line_search; //5
+  int max_num_steps{500};                   // 3
+  int allow_fallthrough{true};              // 4
+  laplace_line_search_options line_search;  // 5
   laplace_options_base() = default;
   laplace_options_base(int hessian_block_size_, int solver_, double tolerance_,
                        int max_num_steps_, bool allow_fallthrough_,
@@ -79,16 +79,16 @@ struct laplace_options<false> : public laplace_options_base {};
 template <>
 struct laplace_options<true> : public laplace_options_base {
   /* Value for user supplied initial theta  */
-  Eigen::VectorXd theta_0{0}; // 6
+  Eigen::VectorXd theta_0{0};  // 6
 
   template <typename ThetaVec>
   laplace_options(ThetaVec&& theta_0_, int hessian_block_size_, int solver_,
                   double tolerance_, int max_num_steps_,
                   bool allow_fallthrough_, int max_steps_line_search_)
       : laplace_options_base(hessian_block_size_, solver_, tolerance_,
-                             max_num_steps_, allow_fallthrough_, max_steps_line_search_),
-                             theta_0(std::forward<ThetaVec>(theta_0_)) {
-  }
+                             max_num_steps_, allow_fallthrough_,
+                             max_steps_line_search_),
+        theta_0(std::forward<ThetaVec>(theta_0_)) {}
 };
 
 using laplace_options_default = laplace_options<false>;
@@ -101,84 +101,80 @@ using laplace_options_user_supplied = laplace_options<true>;
  */
 inline auto generate_laplace_options(int theta_0_size) {
   auto ops = laplace_options_default{};
-  return std::make_tuple(Eigen::VectorXd::Zero(theta_0_size).eval(), //0 -> 6
-    ops.tolerance,
-    ops.max_num_steps,
-    ops.hessian_block_size,
-    ops.solver,
-    ops.line_search.max_iterations,
-    static_cast<int>(ops.allow_fallthrough)
-  );
+  return std::make_tuple(
+      Eigen::VectorXd::Zero(theta_0_size).eval(),  // 0 -> 6
+      ops.tolerance, ops.max_num_steps, ops.hessian_block_size, ops.solver,
+      ops.line_search.max_iterations, static_cast<int>(ops.allow_fallthrough));
 }
 
-
 namespace internal {
 
 template <std::size_t N, typename Tuple, typename CheckType>
-inline constexpr bool is_tuple_type_v = std::is_same_v<std::decay_t<CheckType>, std::tuple_element_t<N, std::decay_t<Tuple>>>;
+inline constexpr bool is_tuple_type_v
+    = std::is_same_v<std::decay_t<CheckType>,
+                     std::tuple_element_t<N, std::decay_t<Tuple>>>;
 
 template <typename Ops>
 inline constexpr auto tuple_to_laplace_options(Ops&& ops) {
   if constexpr (is_tuple_v<Ops>) {
     if constexpr (!is_eigen_v<std::tuple_element_t<0, std::decay_t<Ops>>>) {
       static_assert(
-        sizeof(std::decay_t<Ops>*) == 0,
-        "ERROR:(laplace_marginal_lpdf) The first laplace argument is "
-        "expected to be an Eigen vector of dynamic size representing the "
-        "initial theta_0.");
+          sizeof(std::decay_t<Ops>*) == 0,
+          "ERROR:(laplace_marginal_lpdf) The first laplace argument is "
+          "expected to be an Eigen vector of dynamic size representing the "
+          "initial theta_0.");
     }
     if constexpr (!is_tuple_type_v<1, Ops, double>) {
       static_assert(
-        sizeof(std::decay_t<Ops>*) == 0,
-        "ERROR:(laplace_marginal_lpdf) The second laplace argument is "
-        "expected to be a double representing the tolerance.");
-
+          sizeof(std::decay_t<Ops>*) == 0,
+          "ERROR:(laplace_marginal_lpdf) The second laplace argument is "
+          "expected to be a double representing the tolerance.");
     }
     if constexpr (!is_tuple_type_v<2, Ops, int>) {
       static_assert(
-        sizeof(std::decay_t<Ops>*) == 0,
-        "ERROR:(laplace_marginal_lpdf) The third laplace argument is "
-        "expected to be an int representing the maximum number of steps.");
+          sizeof(std::decay_t<Ops>*) == 0,
+          "ERROR:(laplace_marginal_lpdf) The third laplace argument is "
+          "expected to be an int representing the maximum number of steps.");
     }
     if constexpr (!is_tuple_type_v<3, Ops, int>) {
       static_assert(
-        sizeof(std::decay_t<Ops>*) == 0,
-        "ERROR:(laplace_marginal_lpdf) The fourth laplace argument is "
-        "expected to be an int representing the solver.");
+          sizeof(std::decay_t<Ops>*) == 0,
+          "ERROR:(laplace_marginal_lpdf) The fourth laplace argument is "
+          "expected to be an int representing the solver.");
     }
     if constexpr (!is_tuple_type_v<4, Ops, int>) {
       static_assert(
-        sizeof(std::decay_t<Ops>*) == 0,
-        "ERROR:(laplace_marginal_lpdf) The fifth laplace argument is "
-        "expected to be an int representing the hessian block size.");
+          sizeof(std::decay_t<Ops>*) == 0,
+          "ERROR:(laplace_marginal_lpdf) The fifth laplace argument is "
+          "expected to be an int representing the hessian block size.");
     }
     if constexpr (!is_tuple_type_v<5, Ops, int>) {
       static_assert(
-        sizeof(std::decay_t<Ops>*) == 0,
-        "ERROR:(laplace_marginal_lpdf) The sixth laplace argument is "
-        "expected to be an int representing the max steps line search.");
+          sizeof(std::decay_t<Ops>*) == 0,
+          "ERROR:(laplace_marginal_lpdf) The sixth laplace argument is "
+          "expected to be an int representing the max steps line search.");
     }
-    if constexpr (!(is_tuple_type_v<6, Ops, int> || is_tuple_type_v<6, Ops, bool>)) {
+    if constexpr (!(is_tuple_type_v<6, Ops,
+                                    int> || is_tuple_type_v<6, Ops, bool>)) {
       static_assert(
-        sizeof(std::decay_t<Ops>*) == 0,
-        "ERROR:(laplace_marginal_lpdf) The seventh laplace argument is "
-        "expected to be an int representing allow fallthrough (0/1).");
+          sizeof(std::decay_t<Ops>*) == 0,
+          "ERROR:(laplace_marginal_lpdf) The seventh laplace argument is "
+          "expected to be an int representing allow fallthrough (0/1).");
     }
     return laplace_options_user_supplied{
-      value_of(std::get<0>(std::forward<Ops>(ops))),
-      std::get<3>(ops),
-      std::get<4>(ops),
-      std::get<1>(ops),
-      std::get<2>(ops),
-      (std::get<6>(ops) > 0) ? true : false,
-      std::get<5>(ops),
+        value_of(std::get<0>(std::forward<Ops>(ops))),
+        std::get<3>(ops),
+        std::get<4>(ops),
+        std::get<1>(ops),
+        std::get<2>(ops),
+        (std::get<6>(ops) > 0) ? true : false,
+        std::get<5>(ops),
     };
   } else {
     return std::forward<Ops>(ops);
   }
 }
 
-
 template <typename ThetaVec, typename WR, typename L_t, typename A_vec,
           typename ThetaGrad, typename LU_t, typename KRoot>
 struct laplace_density_estimates {
@@ -1094,12 +1090,12 @@ inline auto run_newton_loop(SolverPolicy& solver, NewtonStateT& state,
  * @param next_solver Name of the solver being attempted next
  * @param e Exception that caused the fallback
  */
-inline void log_solver_fallback(const bool allow_fallthrough, std::ostream* msgs, std::string_view context,
+inline void log_solver_fallback(const bool allow_fallthrough,
+                                std::ostream* msgs, std::string_view context,
                                 Eigen::Index iter,
                                 std::string_view failed_solver,
                                 std::string_view next_solver,
                                 const std::exception& e) {
-
   // Build once so we don't interleave with other logs.
   std::ostringstream os;
   os << "[" << context << "] WARNING: solver fallback\n"
@@ -1109,13 +1105,10 @@ inline void log_solver_fallback(const bool allow_fallthrough, std::ostream* msgs
      << "  " << std::left << std::setw(12) << "action:"
      << "trying " << next_solver << "\n";
   if (!allow_fallthrough) {
-    throw std::domain_error(
-        std::string("[") + std::string(context)
-        + "]");
+    throw std::domain_error(std::string("[") + std::string(context) + "]");
   } else if (msgs) {
     (*msgs) << os.str();
   }
-
 }
 
 /**
@@ -1297,7 +1290,8 @@ inline auto laplace_marginal_density_est(
     std::string solver_type
         = (options.hessian_block_size == 1) ? "Diagonal" : "Block";
     std::string failed = "solver 1 (" + solver_type + " Hessian-root Cholesky)";
-    log_solver_fallback(options.allow_fallthrough, msgs, "laplace_marginal_density", step_iter, failed,
+    log_solver_fallback(options.allow_fallthrough, msgs,
+                        "laplace_marginal_density", step_iter, failed,
                         "solver 2 (Covariance-root Cholesky)", e);
   }
   try {
@@ -1308,7 +1302,8 @@ inline auto laplace_marginal_density_est(
                              throw_overstep, msgs);
     }
   } catch (const std::exception& e) {
-    log_solver_fallback(options.allow_fallthrough, msgs, "laplace_marginal_density", step_iter,
+    log_solver_fallback(options.allow_fallthrough, msgs,
+                        "laplace_marginal_density", step_iter,
                         "solver 2 (Covariance-root Cholesky)",
                         "solver 3 (General LU solver)", e);
   }

stan/math/mix/prob/laplace_latent_bernoulli_logit_rng.hpp

@@ -28,18 +28,19 @@ namespace math {
  * \rng_arg
  * \msg_arg
  */
-template <typename Mean, typename CovarFun,
-          typename CovarArgs, typename OpsTuple, typename RNG>
+template <typename Mean, typename CovarFun, typename CovarArgs,
+          typename OpsTuple, typename RNG>
 inline Eigen::VectorXd laplace_latent_tol_bernoulli_logit_rng(
     const std::vector<int>& y, const std::vector<int>& n_samples, Mean&& mean,
-    CovarFun&& covariance_function, CovarArgs&& covar_args, OpsTuple&& ops, RNG& rng, std::ostream* msgs) {
+    CovarFun&& covariance_function, CovarArgs&& covar_args, OpsTuple&& ops,
+    RNG& rng, std::ostream* msgs) {
   return laplace_base_rng(
       bernoulli_logit_likelihood{},
       std::forward_as_tuple(to_vector(y), n_samples, std::forward<Mean>(mean)),
       std::forward<CovarFun>(covariance_function),
       std::forward<CovarArgs>(covar_args),
-      internal::tuple_to_laplace_options(std::forward<OpsTuple>(ops)),
-      rng, msgs);
+      internal::tuple_to_laplace_options(std::forward<OpsTuple>(ops)), rng,
+      msgs);
 }
 
 /**

stan/math/mix/prob/laplace_latent_neg_binomial_2_log_rng.hpp

@@ -35,8 +35,8 @@ namespace math {
  * \rng_arg
  * \msg_arg
  */
-template <typename Eta, typename Mean, typename CovarFun,
-          typename CovarArgs, typename OpsTuple, typename RNG>
+template <typename Eta, typename Mean, typename CovarFun, typename CovarArgs,
+          typename OpsTuple, typename RNG>
 inline Eigen::VectorXd laplace_latent_tol_neg_binomial_2_log_rng(
     const std::vector<int>& y, const std::vector<int>& y_index, Eta&& eta,
     Mean&& mean, CovarFun&& covariance_function, CovarArgs&& covar_args,
@@ -47,8 +47,8 @@ inline Eigen::VectorXd laplace_latent_tol_neg_binomial_2_log_rng(
                             std::forward<Mean>(mean)),
       std::forward<CovarFun>(covariance_function),
       std::forward<CovarArgs>(covar_args),
-      internal::tuple_to_laplace_options(std::forward<OpsTuple>(ops)),
-      rng, msgs);
+      internal::tuple_to_laplace_options(std::forward<OpsTuple>(ops)), rng,
+      msgs);
 }
 
 /**

stan/math/mix/prob/laplace_latent_poisson_log_rng.hpp

@@ -30,20 +30,19 @@ namespace math {
  * \rng_arg
  * \msg_arg
  */
-template <typename Mean, typename CovarFun,
-          typename CovarArgs, typename OpsTuple, typename RNG>
+template <typename Mean, typename CovarFun, typename CovarArgs,
+          typename OpsTuple, typename RNG>
 inline Eigen::VectorXd laplace_latent_tol_poisson_log_rng(
     const std::vector<int>& y, const std::vector<int>& y_index, Mean&& mean,
-    CovarFun&& covariance_function, CovarArgs&& covar_args,
-    OpsTuple&& ops,
+    CovarFun&& covariance_function, CovarArgs&& covar_args, OpsTuple&& ops,
     RNG& rng, std::ostream* msgs) {
   return laplace_base_rng(
       poisson_log_likelihood{},
       std::forward_as_tuple(y, y_index, std::forward<Mean>(mean)),
       std::forward<CovarFun>(covariance_function),
       std::forward<CovarArgs>(covar_args),
-      internal::tuple_to_laplace_options(std::forward<OpsTuple>(ops)),
-      rng, msgs);
+      internal::tuple_to_laplace_options(std::forward<OpsTuple>(ops)), rng,
+      msgs);
 }
 
 /**

stan/math/mix/prob/laplace_latent_rng.hpp

@@ -29,17 +29,18 @@ namespace math {
  * \rng_arg
  * \msg_arg
  */
-template <typename LLFunc, typename LLArgs,
-          typename CovarFun, typename CovarArgs, typename OpsTuple, typename RNG>
-inline auto laplace_latent_tol_rng(
-    LLFunc&& L_f, LLArgs&& ll_args, CovarFun&& covariance_function,
-    CovarArgs&& covar_args, OpsTuple&& ops, RNG& rng, std::ostream* msgs) {
-  return laplace_base_rng(std::forward<LLFunc>(L_f),
-                          std::forward<LLArgs>(ll_args),
-                          std::forward<CovarFun>(covariance_function),
-                          std::forward<CovarArgs>(covar_args),
-                          internal::tuple_to_laplace_options(std::forward<OpsTuple>(ops)),
-                          rng, msgs);
+template <typename LLFunc, typename LLArgs, typename CovarFun,
+          typename CovarArgs, typename OpsTuple, typename RNG>
+inline auto laplace_latent_tol_rng(LLFunc&& L_f, LLArgs&& ll_args,
+                                   CovarFun&& covariance_function,
+                                   CovarArgs&& covar_args, OpsTuple&& ops,
+                                   RNG& rng, std::ostream* msgs) {
+  return laplace_base_rng(
+      std::forward<LLFunc>(L_f), std::forward<LLArgs>(ll_args),
+      std::forward<CovarFun>(covariance_function),
+      std::forward<CovarArgs>(covar_args),
+      internal::tuple_to_laplace_options(std::forward<OpsTuple>(ops)), rng,
+      msgs);
 }
 
 /**

stan/math/mix/prob/laplace_marginal.hpp

@@ -27,9 +27,10 @@ namespace math {
  */
 template <bool propto = false, typename LFun, typename LArgs, typename CovarFun,
           typename CovarArgs, typename OpsTuple>
-inline auto laplace_marginal_tol(
-    LFun&& L_f, LArgs&& l_args, CovarFun&& covariance_function,
-    CovarArgs&& covar_args, OpsTuple&& ops,std::ostream* msgs) {
+inline auto laplace_marginal_tol(LFun&& L_f, LArgs&& l_args,
+                                 CovarFun&& covariance_function,
+                                 CovarArgs&& covar_args, OpsTuple&& ops,
+                                 std::ostream* msgs) {
   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

@@ -52,12 +52,12 @@ struct bernoulli_logit_likelihood {
  * \laplace_options
  * \msg_arg
  */
-template <bool propto = false, typename Mean,
-          typename CovarFun, typename CovarArgs, typename OpsTuple>
+template <bool propto = false, typename Mean, typename CovarFun,
+          typename CovarArgs, typename OpsTuple>
 inline auto laplace_marginal_tol_bernoulli_logit_lpmf(
     const std::vector<int>& y, const std::vector<int>& n_samples, Mean&& mean,
-    CovarFun&& covariance_function, CovarArgs&& covar_args,
-    OpsTuple&& ops, std::ostream* msgs) {
+    CovarFun&& covariance_function, CovarArgs&& covar_args, OpsTuple&& ops,
+    std::ostream* msgs) {
   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

@@ -76,8 +76,8 @@ struct neg_binomial_2_log_likelihood {
  * \laplace_options
  * \msg_arg
  */
-template <bool propto = false, typename Eta, typename Mean,
-          typename CovarFun, typename CovarArgs, typename OpsTuple>
+template <bool propto = false, typename Eta, typename Mean, typename CovarFun,
+          typename CovarArgs, typename OpsTuple>
 inline auto laplace_marginal_tol_neg_binomial_2_log_lpmf(
     const std::vector<int>& y, const std::vector<int>& y_index, const Eta& eta,
     Mean&& mean, CovarFun&& covariance_function, CovarArgs&& covar_args,
@@ -170,13 +170,13 @@ struct neg_binomial_2_log_likelihood_summary {
  * \laplace_options
  * \msg_arg
  */
-template <bool propto = false, typename Eta, typename Mean,
-          typename CovarFun, typename CovarArgs, typename OpsTuple>
+template <bool propto = false, typename Eta, typename Mean, typename CovarFun,
+          typename CovarArgs, typename OpsTuple>
 inline auto laplace_marginal_tol_neg_binomial_2_log_summary_lpmf(
     const std::vector<int>& y, const std::vector<int>& n_per_group,
     const std::vector<int>& counts_per_group, const Eta& eta, Mean&& mean,
-    CovarFun&& covariance_function, CovarArgs&& covar_args,
-    OpsTuple&& ops, std::ostream* msgs) {
+    CovarFun&& covariance_function, CovarArgs&& covar_args, OpsTuple&& ops,
+    std::ostream* msgs) {
   return laplace_marginal_density(
       neg_binomial_2_log_likelihood_summary{},
       std::forward_as_tuple(eta, y, n_per_group, counts_per_group,