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

Author: stan-buildbot

stan/math/mix/functor/laplace_marginal_density_estimator.hpp

@@ -444,7 +444,8 @@ inline void llt_with_jitter(LLT& llt_B, B_t& B, double min_jitter = 1e-10,
     }
     if (llt_B.info() != Eigen::Success) {
       throw std::domain_error(
-          "laplace_marginal_density: Cholesky failed after adding jitter up to " + std::to_string(jitter_try));
+          "laplace_marginal_density: Cholesky failed after adding jitter up to "
+          + std::to_string(jitter_try));
     }
   }
 }
@@ -964,10 +965,11 @@ inline auto run_newton_loop(SolverPolicy& solver, NewtonStateT& state,
        * Stop when objective change is small, or when a rejected Wolfe step
        * fails to improve; finish_update then exits the Newton loop.
        */
-      bool objective_converged = std::abs(state.curr().obj() - state.prev().obj())
-                          < options.tolerance;
+      bool objective_converged
+          = std::abs(state.curr().obj() - state.prev().obj())
+            < options.tolerance;
       bool search_failed = (!state.wolfe_status.accept_
-                          && state.curr().obj() <= state.prev().obj());
+                            && state.curr().obj() <= state.prev().obj());
       finish_update = objective_converged || search_failed;
     }
     if (finish_update) {
@@ -1037,8 +1039,10 @@ inline decltype(auto) theta_init_impl(Eigen::Index theta_size, Opts&& options) {
 /**
  * @brief Create the update function for the line search, capturing necessary
  * references.
- * @tparam ObjFun Callable type for the objective function (accepting (a, theta))
- * @tparam ThetaGradFun Callable type for the theta gradient function (accepting theta)
+ * @tparam ObjFun Callable type for the objective function (accepting (a,
+ * theta))
+ * @tparam ThetaGradFun Callable type for the theta gradient function (accepting
+ * theta)
  * @tparam Covariance Type of the covariance matrix
  * @tparam Options Type of the options struct containing line search parameters
  * @param[in] obj_fun Objective function functor
@@ -1050,12 +1054,13 @@ inline decltype(auto) theta_init_impl(Eigen::Index theta_size, Opts&& options) {
  *  bool update_fun(proposal, curr, prev, eval_in, p)
  * ```
  */
-template <typename ObjFun, typename ThetaGradFun, typename Covariance, typename Options>
+template <typename ObjFun, typename ThetaGradFun, typename Covariance,
+          typename Options>
 inline auto create_update_fun(ObjFun&& obj_fun, ThetaGradFun&& theta_grad_f,
-                             Covariance&& covariance, Options&& options) {
+                              Covariance&& covariance, Options&& options) {
   auto update_step = [&covariance, &obj_fun, &theta_grad_f](
-                          auto& proposal, auto&& /* curr */, auto&& prev,
-                          auto& eval_in, auto&& p) {
+                         auto& proposal, auto&& /* curr */, auto&& prev,
+                         auto& eval_in, auto&& p) {
     try {
       proposal.a() = prev.a() + eval_in.alpha() * p;
       proposal.theta().noalias() = covariance * proposal.a();
@@ -1073,7 +1078,8 @@ inline auto create_update_fun(ObjFun&& obj_fun, ThetaGradFun&& theta_grad_f,
     eval.alpha() *= options.line_search.tau;
     return eval.alpha() > options.line_search.min_alpha;
   };
-  return [update_step_ = std::move(update_step), backoff_ = std::move(backoff)](
+  return
+      [update_step_ = std::move(update_step), backoff_ = std::move(backoff)](
           auto& proposal, auto&& curr, auto&& prev, auto& eval_in, auto&& p) {
         return internal::retry_evaluate(update_step_, proposal, curr, prev,
                                         eval_in, p, backoff_);
@@ -1153,7 +1159,8 @@ inline auto laplace_marginal_density_est(
   decltype(auto) theta_init = theta_init_impl<InitTheta>(theta_size, options);
   internal::NewtonState state(theta_size, obj_fun, theta_grad_f, theta_init);
   // Start with safe step size
-  auto update_fun = create_update_fun(std::move(obj_fun), std::move(theta_grad_f), covariance, options);
+  auto update_fun = create_update_fun(
+      std::move(obj_fun), std::move(theta_grad_f), covariance, options);
   Eigen::Index step_iter = 0;
   try {
     if (options.solver == 1) {

stan/math/mix/functor/wolfe_line_search.hpp

@@ -157,9 +157,9 @@ namespace internal {
  */
 template <typename Scalar>
 [[nodiscard]] inline Scalar cubic_spline(Scalar x_left, Scalar f_left,
-                                                Scalar df_left, Scalar x_right,
-                                                Scalar f_right,
-                                                Scalar df_right) noexcept {
+                                         Scalar df_left, Scalar x_right,
+                                         Scalar f_right,
+                                         Scalar df_right) noexcept {
   const Scalar midpoint = (x_left + x_right) / Scalar(2);
 
   // Basic validation: ordering + finiteness.
@@ -284,8 +284,8 @@ template <typename Scalar>
 
 template <typename Eval, typename Options>
 inline auto cubic_spline(Eval&& low, Eval&& high, Options&& opt) {
-  auto alpha = cubic_spline(low.alpha(), low.obj(), low.dir(),
-                                   high.alpha(), high.obj(), high.dir());
+  auto alpha = cubic_spline(low.alpha(), low.obj(), low.dir(), high.alpha(),
+                            high.obj(), high.dir());
   const double width = high.alpha() - low.alpha();
   const double guard = 1e-3 * width;  // or make this an option
   alpha = std::clamp(alpha, low.alpha() + guard, high.alpha() - guard);
@@ -608,13 +608,13 @@ inline auto retry_evaluate(Update&& update, Proposal&& proposal, Curr&& curr,
  * The search maintains a left endpoint `low`, a right endpoint `high`,
  * and a fallback `best` (best Armijo-satisfying point seen so far).
  * Non-finite evaluations are contracted by factor `opt.tau` automatically.
- * 
+ *
  * ## Phase 1: Aggresive Expansion
  * The user given initial step size is expanded by `opt.scale_up` until
  * either Wolfe conditions are violated or `opt.max_alpha` is reached.
  * If the first evaluation satisfies both conditions, the search expands
  * further ("zoom-up") to find the largest such step before accepting.
- * 
+ *
  * ## Phase 2: Expansion / Bracketing
  *
  * Starting from $\alpha_0 = \text{clamp}(\text{curr.alpha} \cdot
@@ -632,9 +632,9 @@ inline auto retry_evaluate(Update&& update, Proposal&& proposal, Curr&& curr,
  * | T      | F     | <= 0  | Bracket found, go to zoom |
  * | F      | -     | -     | Bracket found, go to zoom |
  * ```
- * 
+ *
  * The goal of this phase is to find a valid bracket `[low, high]`
- * Ideally such that the low endpoint satisfies Armijo and has 
+ * Ideally such that the low endpoint satisfies Armijo and has
  * a positive derivative, while the high endpoint has a negative
  * derivative. This gives us a shape like /\ to search through
  * in the zoom phase. If such a bracket cannot be found
@@ -790,10 +790,10 @@ inline WolfeStatus wolfe_line_search(Info& wolfe_info, UpdateFun&& update_fun,
       return wolfe_check;
     }
     if (check_armijo(high, prev, opt)) {
-      if (check_wolfe(high, prev, opt)) { // [1]
+      if (check_wolfe(high, prev, opt)) {  // [1]
         curr.update(scratch, high);
         return WolfeStatus{WolfeReturn::Wolfe, total_updates, num_backtracks,
-                          true};
+                           true};
       }
       if (best.obj() < high.obj()) {
         best = high;
@@ -887,7 +887,7 @@ inline WolfeStatus wolfe_line_search(Info& wolfe_info, UpdateFun&& update_fun,
                          num_backtracks, false};
     }
     if (check_armijo(mid, prev, opt)) {
-      if (check_wolfe(mid, prev, opt)) { // [1]
+      if (check_wolfe(mid, prev, opt)) {  // [1]
         curr.update(scratch, mid);
         return WolfeStatus{WolfeReturn::Wolfe, total_updates, num_backtracks,
                            true};
@@ -897,16 +897,16 @@ inline WolfeStatus wolfe_line_search(Info& wolfe_info, UpdateFun&& update_fun,
         best = mid;
       }
       if (mid.obj() > low.obj()) {
-        if (mid.dir() > 0) { // [2]
+        if (mid.dir() > 0) {  // [2]
           low = mid;
-        } else { // [3]
+        } else {  // [3]
           high = mid;
         }
       }
       // [4]
-      high = mid; 
-    } else { 
-      // [5] 
+      high = mid;
+    } else {
+      // [5]
       high = mid;
     }
     // Convergence/guard-rail checks (uses prev/grad_tol/obj_tol etc.)

test/unit/math/laplace/laplace_marginal_bernoulli_logit_lpmf_test.cpp

@@ -25,7 +25,7 @@ TEST_P(laplace_marginal_bernoulli_logit_lpmf, phi_dim500) {
   const auto [solver_num, hessian_block_size, max_steps_line_search]
       = GetParam();
   LAPLACE_SKIP_IF_INVALID_TEST_COMBO(hessian_block_size, dim_theta);
-  //LAPLACE_SKIP_ZERO_STEPS(max_steps_line_search);
+  // LAPLACE_SKIP_ZERO_STEPS(max_steps_line_search);
 
   auto x1 = stan::test::laplace::x1;
   auto x2 = stan::test::laplace::x2;

test/unit/math/laplace/wolfe_line_search_test.cpp

@@ -798,8 +798,8 @@ TEST(CubicOrBisect, ReturnsInteriorMaximiser) {
 // Checks that the chooser falls back to the midpoint on non-finite data.
 TEST(CubicOrBisect, FallsBackToMidpointOnNonfinite) {
   using stan::math::internal::cubic_spline;
-  double alpha = cubic_spline(
-      0.0, std::numeric_limits<double>::quiet_NaN(), 1.0, 1.0, -1.0, -0.5);
+  double alpha = cubic_spline(0.0, std::numeric_limits<double>::quiet_NaN(),
+                              1.0, 1.0, -1.0, -0.5);
   EXPECT_DOUBLE_EQ(alpha, 0.5);
 }