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

stan-buildbot · stan-buildbot · commit 7c33da2b47fb · 2025-05-27T17:05:44.000-04:00
diff --git a/stan/math/mix/functor/laplace_likelihood.hpp b/stan/math/mix/functor/laplace_likelihood.hpp
@@ -61,11 +61,13 @@ inline auto conditional_copy_and_promote(Args&&... args) {
               },
               std::forward<decltype(arg)>(arg));
         } else if constexpr (is_std_vector_v<decltype(arg)>) {
-          std::vector<decltype(conditional_copy_and_promote<Filter, PromotedType,
-                                                 CopyType>(arg[0]))> ret;
+          std::vector<decltype(conditional_copy_and_promote<
+                               Filter, PromotedType, CopyType>(arg[0]))>
+              ret;
           for (std::size_t i = 0; i < arg.size(); ++i) {
-            ret.push_back(conditional_copy_and_promote<Filter, PromotedType,
-                                                       CopyType>(arg[i]));
+            ret.push_back(
+                conditional_copy_and_promote<Filter, PromotedType, CopyType>(
+                    arg[i]));
           }
           return ret;
         } else {
diff --git a/stan/math/mix/functor/laplace_marginal_density.hpp b/stan/math/mix/functor/laplace_marginal_density.hpp
@@ -295,7 +295,10 @@ inline void set_zero_adjoint(Output&& output) {
           } else if constexpr (is_stan_scalar_v<output_i_t>) {
             output_i.adj() = 0;
           } else {
-            static_assert(1, "INTERNAL ERROR:(laplace_marginal_lpdf) set_zero_adjoints was not able to deduce the actiopns needed for the given type.");
+            static_assert(
+                1,
+                "INTERNAL ERROR:(laplace_marginal_lpdf) set_zero_adjoints was "
+                "not able to deduce the actiopns needed for the given type.");
           }
         },
         std::forward<Output>(output));
@@ -328,7 +331,10 @@ inline void collect_adjoints(Output& output, Input1&& precalc) {
             precalc_i.adj() = 0;
           }
         } else {
-          static_assert(1, "INTERNAL ERROR:(laplace_marginal_lpdf) collect_adjoints was not able to deduce the actiopns needed for the given type.");
+          static_assert(
+              1,
+              "INTERNAL ERROR:(laplace_marginal_lpdf) collect_adjoints was not "
+              "able to deduce the actiopns needed for the given type.");
         }
       },
       std::forward<Output>(output), std::forward<Input1>(precalc));
@@ -765,10 +771,12 @@ template <typename Output, typename Input1>
 inline void collect_adjoints(Output&& output, const vari* ret,
                              Input1&& precalc) {
   if constexpr (is_tuple_v<Output>) {
-    static_assert(1,"INTERNAL ERROR:(laplace_marginal_lpdf)"
+    static_assert(1,
+                  "INTERNAL ERROR:(laplace_marginal_lpdf)"
                   "Accumulate Adjoints called on a tuple, but tuples cannot be "
                   "on the reverse mode stack!"
-                  "This is an internal error, please report it to the stan github as an issue.");
+                  "This is an internal error, please report it to the stan "
+                  "github as an issue.");
   } else if constexpr (is_std_vector_v<Output>) {
     if constexpr (!is_var_v<value_type_t<Output>>) {
       const auto output_size = output.size();
@@ -806,7 +814,10 @@ inline void collect_adjoints(Output&& output, Input1&& precalc) {
         } else if constexpr (is_stan_scalar_v<output_i_t>) {
           output_i += precalc_i;
         } else {
-          static_assert(1, "INTERNAL ERROR:(laplace_marginal_lpdf) collect_adjoints was not able to deduce the actiopns needed for the given type.");
+          static_assert(
+              1,
+              "INTERNAL ERROR:(laplace_marginal_lpdf) collect_adjoints was not "
+              "able to deduce the actiopns needed for the given type.");
         }
       },
       std::forward<Output>(output), std::forward<Input1>(precalc));
@@ -832,7 +843,10 @@ inline void copy_compute_s2(Output&& output, Input1&& precalc) {
         } else if constexpr (is_stan_scalar_v<output_i_t>) {
           output_i += (0.5 * precalc_i.adj());
         } else {
-          static_assert(1, "INTERNAL ERROR:(laplace_marginal_lpdf) copy_compute_s2 was not able to deduce the actiopns needed for the given type.");
+          static_assert(
+              1,
+              "INTERNAL ERROR:(laplace_marginal_lpdf) copy_compute_s2 was not "
+              "able to deduce the actiopns needed for the given type.");
         }
       },
       std::forward<Output>(output), std::forward<Input1>(precalc));
@@ -886,11 +900,12 @@ inline void print_adjoint(Output&& output) {
   } else if constexpr (is_stan_scalar_v<Output>) {
     std::cout << "adj: " << output.adj() << std::endl;
   } else {
-          static_assert(1, "INTERNAL ERROR:(laplace_marginal_lpdf) print_adjoint was not able to deduce the actiopns needed for the given type.");
+    static_assert(1,
+                  "INTERNAL ERROR:(laplace_marginal_lpdf) print_adjoint was "
+                  "not able to deduce the actiopns needed for the given type.");
   }
 }
 
-
 template <typename Arg, typename Precalc>
 inline void laplace_tuple_collect_adjoints(var ret, Arg&& arg,
                                            Precalc&& precalc) {
diff --git a/stan/math/prim/fun/promote_scalar.hpp b/stan/math/prim/fun/promote_scalar.hpp
@@ -10,22 +10,26 @@
 namespace stan {
 namespace math {
 
-
 template <typename PromotionScalars, typename UnPromotedTypes>
 inline constexpr auto promote_scalar(UnPromotedTypes&& x) {
-  if constexpr (std::is_same_v<PromotionScalars, scalar_type_t<UnPromotedTypes>>) {
+  if constexpr (std::is_same_v<PromotionScalars,
+                               scalar_type_t<UnPromotedTypes>>) {
     return std::forward<UnPromotedTypes>(x);
-  } else if constexpr (is_tuple_v<PromotionScalars> && is_tuple_v<UnPromotedTypes>) {
+  } else if constexpr (is_tuple_v<
+                           PromotionScalars> && is_tuple_v<UnPromotedTypes>) {
     return index_apply<std::tuple_size<std::decay_t<UnPromotedTypes>>::value>(
-      [&x](auto... Is) {
-        return std::make_tuple(
-            promote_scalar<std::decay_t<decltype(std::get<Is>(
-                std::declval<PromotionScalars>()))>>(std::get<Is>(x))...);
-      });
+        [&x](auto... Is) {
+          return std::make_tuple(
+              promote_scalar<std::decay_t<decltype(std::get<Is>(
+                  std::declval<PromotionScalars>()))>>(std::get<Is>(x))...);
+        });
   } else if constexpr (is_tuple_v<UnPromotedTypes>) {
-    return stan::math::apply([](auto&&... args) {
-      return std::make_tuple(promote_scalar<PromotionScalars>(std::forward<decltype(args)>(args))...);
-    }, std::forward<UnPromotedTypes>(x));
+    return stan::math::apply(
+        [](auto&&... args) {
+          return std::make_tuple(promote_scalar<PromotionScalars>(
+              std::forward<decltype(args)>(args))...);
+        },
+        std::forward<UnPromotedTypes>(x));
   } else if constexpr (is_std_vector_v<UnPromotedTypes>) {
     const auto x_size = x.size();
     promote_scalar_t<PromotionScalars, UnPromotedTypes> ret(x_size);
@@ -42,7 +46,6 @@ inline constexpr auto promote_scalar(UnPromotedTypes&& x) {
   }
 }
 
-
 }  // namespace math
 }  // namespace stan
 
diff --git a/stan/math/prim/functor/filter_map.hpp b/stan/math/prim/functor/filter_map.hpp
@@ -16,8 +16,8 @@ namespace internal {
  * Filter a tuple and apply a functor to each element that passes the filter.
  * @note The `Filter` will only check `T` and if `T` is a tuple, it will
  * recursively check each element of the tuple. But it will not inspect into
- * `std::vector` elements automatically. If you want to inspect the inner element
- * of an `std::vector` your type trait must do that itself.
+ * `std::vector` elements automatically. If you want to inspect the inner
+ * element of an `std::vector` your type trait must do that itself.
  * @tparam Filter a struct that accepts one template parameter and has a static
  *  constexpr bool member named value that is true if the type should be
  *  included in the output tuple.
@@ -33,23 +33,25 @@ namespace internal {
  * @return a tuple with the functor applied to each element which passed the
  * filter.
  */
-template <template <typename...> class Filter, bool InVector = false, bool InTuple = false,
-  typename F, typename T>
+template <template <typename...> class Filter, bool InVector = false,
+          bool InTuple = false, typename F, typename T>
 inline constexpr decltype(auto) filter_map(F&& f, T&& x) {
   if constexpr (inspect_tuple_v<Filter, T>) {
     if constexpr (is_tuple_v<T>) {
-      auto ret = stan::math::apply([&f](auto&&... args) {
-        return stan::math::tuple_concat(
-          filter_map<Filter, false, true>(f, std::forward<decltype(args)>(args))...
-        );
-      }, std::forward<T>(x));
+      auto ret = stan::math::apply(
+          [&f](auto&&... args) {
+            return stan::math::tuple_concat(filter_map<Filter, false, true>(
+                f, std::forward<decltype(args)>(args))...);
+          },
+          std::forward<T>(x));
       /* If we are in at this stage, we want tuple_concat to return a tuple here
        * So we return a tuple(tuple()) so that tuple_cat concats
        * the first layer of tuple.
-       * For example, if our input is a tuple(double, tuple(double, vec<double>))
-       * with an identity filter we want tuple_concat to return a
+       * For example, if our input is a tuple(double, tuple(double,
+       * vec<double>)) with an identity filter we want tuple_concat to return a
        * tuple(double, tuple(double, vec<double>)).
-       * Without the double tuple we would get back a tuple(double, double, vec<double>).
+       * Without the double tuple we would get back a tuple(double, double,
+       * vec<double>).
        */
       if constexpr (InTuple) {
         return partially_forward_as_tuple(std::move(ret));
@@ -77,27 +79,29 @@ inline constexpr decltype(auto) filter_map(F&& f, T&& x) {
         if constexpr (InVector) {
           return std::forward<F>(f)(std::forward<T>(x));
         } else {
-          return partially_forward_as_tuple(std::forward<F>(f)(std::forward<T>(x)));
+          return partially_forward_as_tuple(
+              std::forward<F>(f)(std::forward<T>(x)));
         }
       }
     } else {
       if constexpr (InVector) {
         return std::forward<F>(f)(std::forward<T>(x));
       } else {
-        return partially_forward_as_tuple(std::forward<F>(f)(std::forward<T>(x)));
+        return partially_forward_as_tuple(
+            std::forward<F>(f)(std::forward<T>(x)));
       }
     }
   } else {
     return std::make_tuple();
   }
 }
-}
+}  // namespace internal
 /**
  * Filter a tuple and apply a functor to each element that passes the filter.
  * @note The `Filter` will only check `T` and if `T` is a tuple, it will
  * recursively check each element of the tuple. But it will not inspect into
- * `std::vector` elements automatically. If you want to inspect the inner element
- * of an `std::vector` your type trait must do that itself.
+ * `std::vector` elements automatically. If you want to inspect the inner
+ * element of an `std::vector` your type trait must do that itself.
  * @tparam Filter a struct that accepts one template parameter and has a static
  *  constexpr bool member named value that is true if the type should be
  *  included in the output tuple.
@@ -108,11 +112,10 @@ inline constexpr decltype(auto) filter_map(F&& f, T&& x) {
  * @return a tuple with the functor applied to each element which passed the
  * filter.
  */
-template <template <typename...> class Filter,
-  typename F, typename T, require_tuple_t<T>* = nullptr>
+template <template <typename...> class Filter, typename F, typename T,
+          require_tuple_t<T>* = nullptr>
 inline constexpr decltype(auto) filter_map(F&& f, T&& x) {
-  return internal::filter_map<Filter>(
-      std::forward<F>(f), std::forward<T>(x));
+  return internal::filter_map<Filter>(std::forward<F>(f), std::forward<T>(x));
 }
 }  // namespace math
 }  // namespace stan
diff --git a/stan/math/prim/functor/tuple_concat.hpp b/stan/math/prim/functor/tuple_concat.hpp
@@ -43,10 +43,7 @@ inline auto constexpr tuple_concat_impl(Tuple1&& x, Tuple2&& y, Tuple3&& z,
  * @tparam Tuple Tuple type.
  * @param x Tuple.
  */
-inline constexpr auto tuple_concat() noexcept {
-  return std::make_tuple();
-}
-
+inline constexpr auto tuple_concat() noexcept { return std::make_tuple(); }
 
 /**
  * Base case to pass a tuple forward.
diff --git a/stan/math/prim/meta/contains_tuple.hpp b/stan/math/prim/meta/contains_tuple.hpp
@@ -14,15 +14,16 @@ template <typename T, typename... VecArgs>
 struct contains_tuple_impl<std::vector<T, VecArgs...>> {
   static constexpr bool value = contains_tuple_impl<T>::value;
 };
-}
+}  // namespace internal
 
 /**
  * Check if the type is a tuple or contains a tuple
  * @tparam T type to check
  */
 template <typename T>
 struct contains_tuple {
-  static constexpr bool value = internal::contains_tuple_impl<std::decay_t<T>>::value;
+  static constexpr bool value
+      = internal::contains_tuple_impl<std::decay_t<T>>::value;
 };
 template <typename T>
 inline constexpr bool contains_tuple_v = contains_tuple<std::decay_t<T>>::value;
@@ -31,7 +32,8 @@ inline constexpr bool contains_tuple_v = contains_tuple<std::decay_t<T>>::value;
  * Check if the type is a std::vector containing a tuple
  */
 template <typename T>
-inline constexpr bool is_std_vector_containing_tuple_v = is_std_vector_v<std::decay_t<T>> && contains_tuple_v<std::decay_t<T>>;
+inline constexpr bool is_std_vector_containing_tuple_v
+    = is_std_vector_v<std::decay_t<T>>&& contains_tuple_v<std::decay_t<T>>;
 
 namespace internal {
 template <template <typename...> class Filter, typename T>
@@ -41,10 +43,10 @@ struct inspect_tuple {
 
 template <template <typename...> class Filter, typename... Types>
 struct inspect_tuple<Filter, std::tuple<Types...>> {
-  static constexpr bool value = Filter<std::tuple<Types...>>::value ||
-    (inspect_tuple<Filter, Types>::value || ...);
+  static constexpr bool value = Filter<std::tuple<Types...>>::value
+                                || (inspect_tuple<Filter, Types>::value || ...);
 };
-}
+}  // namespace internal
 
 /**
  * Check if a tuple or type contains a tuple that passes the filter.
@@ -54,8 +56,8 @@ struct inspect_tuple<Filter, std::tuple<Types...>> {
  * @tparam T type to check
  */
 template <template <typename...> class Filter, typename T>
-inline constexpr bool inspect_tuple_v =
-    internal::inspect_tuple<Filter, std::decay_t<T>>::value;
-}
+inline constexpr bool inspect_tuple_v
+    = internal::inspect_tuple<Filter, std::decay_t<T>>::value;
+}  // namespace stan
 
 #endif
diff --git a/test/unit/math/laplace/laplace_marginal_lpdf_test.cpp b/test/unit/math/laplace/laplace_marginal_lpdf_test.cpp
@@ -156,7 +156,9 @@ TEST(laplace, poisson_log_phi_dim_2_array_tuple) {
       [&](int solver_num, int hessian_block_size, int max_steps_line_search,
           auto&& theta_0) {
         auto f_ll = [&](auto&& alpha_rho, auto&& eta1, auto&& eta2) {
-          std::vector<std::tuple<std::decay_t<decltype(eta1)>, std::decay_t<decltype(eta2)>>> eta_tuple;
+          std::vector<std::tuple<std::decay_t<decltype(eta1)>,
+                                 std::decay_t<decltype(eta2)>>>
+              eta_tuple;
           eta_tuple.push_back(std::make_tuple(eta1, eta2));
           using alpha_scalar = stan::scalar_type_t<decltype(alpha_rho)>;
           std::vector<std::tuple<alpha_scalar, alpha_scalar>> alpha_tuple;
@@ -165,9 +167,8 @@ TEST(laplace, poisson_log_phi_dim_2_array_tuple) {
               poisson_log_likelihood_array_tuple{},
               std::forward_as_tuple(sums, eta_tuple), theta_0,
               stan::math::test::squared_kernel_functor{},
-              std::forward_as_tuple(x, alpha_tuple),
-              tolerance, max_num_steps, hessian_block_size, solver_num,
-              max_steps_line_search, nullptr);
+              std::forward_as_tuple(x, alpha_tuple), tolerance, max_num_steps,
+              hessian_block_size, solver_num, max_steps_line_search, nullptr);
         };
         auto test1 = 1.0;
         auto test2 = 1.0;
diff --git a/test/unit/math/laplace/laplace_utility.hpp b/test/unit/math/laplace/laplace_utility.hpp
@@ -134,7 +134,8 @@ struct squared_kernel_functor {
   Eigen::Matrix<return_type_t<T1, T2, T3>, Eigen::Dynamic, Eigen::Dynamic>
   operator()(const T1& x, const std::vector<std::tuple<T2, T3>>& arg1,
              std::ostream* msgs = nullptr) const {
-    return stan::math::gp_exp_quad_cov(x, std::get<0>(arg1[0]), std::get<1>(arg1[0]))
+    return stan::math::gp_exp_quad_cov(x, std::get<0>(arg1[0]),
+                                       std::get<1>(arg1[0]))
            + 1e-9 * Eigen::MatrixXd::Identity(x.size(), x.size());
   }
 };
diff --git a/test/unit/math/prim/functor/filter_map_test.cpp b/test/unit/math/prim/functor/filter_map_test.cpp
