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

Author: stan-buildbot

stan/math/mix/functor/laplace_marginal_density.hpp

@@ -873,9 +873,10 @@ inline void copy_compute_s2(Output&& output, Input&& input) {
 template <typename T>
 inline constexpr decltype(auto) filter_var_scalar_types(T&& t) {
   return stan::math::filter_map<is_any_var_scalar>(
-    [](auto&& arg) -> decltype(auto) {
-      return std::forward<decltype(arg)>(arg);
-    }, std::forward<T>(t));
+      [](auto&& arg) -> decltype(auto) {
+        return std::forward<decltype(arg)>(arg);
+      },
+      std::forward<T>(t));
 }
 /**
  * Creates an arena type from the input with initialized with zeros
@@ -1144,7 +1145,8 @@ inline auto laplace_marginal_density(const LLFun& ll_fun, LLTupleArgs&& ll_args,
           K_var.adj().array() += vi.adj() * K_adj_arena.array();
         });
         grad(Z.vi_);
-        auto covar_args_filter = internal::filter_var_scalar_types(covar_args_copy);
+        auto covar_args_filter
+            = internal::filter_var_scalar_types(covar_args_copy);
         internal::collect_adjoints(covar_args_adj, covar_args_filter);
       }();
     }

stan/math/prim/fun/promote_scalar.hpp

@@ -45,7 +45,8 @@ inline constexpr auto promote_scalar(UnPromotedTypes&& x) {
   } else if constexpr (is_stan_scalar_v<UnPromotedTypes>) {
     return PromotionScalars(std::forward<UnPromotedTypes>(x));
   } else {
-    static_assert(sizeof(UnPromotedTypes*) == 0, "Missed type in promote_scalar!");
+    static_assert(sizeof(UnPromotedTypes*) == 0,
+                  "Missed type in promote_scalar!");
   }
 }
 

stan/math/prim/fun/scalar_seq_view.hpp

@@ -126,7 +126,8 @@ class scalar_seq_view<C, require_t<std::is_pointer<C>>> {
    */
   inline auto operator[](size_t i) const { return c_[i]; }
   inline auto size() const noexcept {
-    static_assert(sizeof(C*) == 0, "Cannot Return Size of scalar_seq_view with pointer type");
+    static_assert(sizeof(C*) == 0,
+                  "Cannot Return Size of scalar_seq_view with pointer type");
   }
   inline const auto* data() const noexcept { return &c_[0]; }
 

stan/math/prim/fun/to_ref.hpp

@@ -29,8 +29,7 @@ template <typename T, require_tuple_t<T>* = nullptr>
 inline auto to_ref(T&& a) {
   return apply(
       [](auto&&... args) {
-        return make_holder_tuple(
-            to_ref(std::forward<decltype(args)>(args))...);
+        return make_holder_tuple(to_ref(std::forward<decltype(args)>(args))...);
       },
       std::forward<T>(a));
 }

stan/math/prim/functor/filter_map.hpp

@@ -12,7 +12,6 @@
 namespace stan {
 namespace math {
 
-
 namespace internal {
 
 template <template <typename...> class Filter, typename T>
@@ -28,8 +27,9 @@ struct inspect_tuple<Filter, std::tuple<Types...>> {
 
 template <template <typename...> class Filter, typename T, typename... VecArgs>
 struct inspect_tuple<Filter, std::vector<T, VecArgs...>> {
-  static constexpr bool value = Filter<std::vector<T, VecArgs...>>::value
-                                || inspect_tuple<Filter, std::decay_t<T>>::value;
+  static constexpr bool value
+      = Filter<std::vector<T, VecArgs...>>::value
+        || inspect_tuple<Filter, std::decay_t<T>>::value;
 };
 
 /**
@@ -40,7 +40,8 @@ struct inspect_tuple<Filter, std::vector<T, VecArgs...>> {
  * @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;
 
 /**
  * Filter a tuple and apply a functor to each element that passes the filter.
@@ -49,8 +50,9 @@ inline constexpr bool inspect_tuple_v = internal::inspect_tuple<Filter, std::dec
  * Note that this function automatically inspects into tuples and
  * `std::vector<T>::value_type`'s. The `filter_map` will recursively apply
  * itself to inner containers as long as it sees a tuple in type type.
- *  So for instance if your type is a `tuple<vector<tuple<vector<vector<double>>>>`
- *  your functor `f` must support operationg on `vector<vector<double>>` types.
+ *  So for instance if your type is a
+ * `tuple<vector<tuple<vector<vector<double>>>>` your functor `f` must support
+ * operationg on `vector<vector<double>>` types.
  * @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.
@@ -93,11 +95,11 @@ inline constexpr decltype(auto) filter_map(F&& f, T&& x) {
         return ret;
       }
     } else if constexpr (is_std_vector_v<T>) {
-     /* 3 cases for vectors
-      * 1. value_type is a tuple
-      * 2. value_type is a scalar or Eigen matrix
-      * 3. value_type is a std::vector which can hold either (1) or (2)
-      */
+      /* 3 cases for vectors
+       * 1. value_type is a tuple
+       * 2. value_type is a scalar or Eigen matrix
+       * 3. value_type is a std::vector which can hold either (1) or (2)
+       */
       if constexpr (contains_tuple<T>::value) {
         std::vector<decltype(filter_map<Filter, true>(f, x[0]))> ret;
         for (size_t i = 0; i < x.size(); ++i) {
@@ -116,16 +118,14 @@ inline constexpr decltype(auto) filter_map(F&& f, T&& x) {
         if constexpr (InVector) {
           return std::forward<F>(f)(std::forward<T>(x));
         } else {
-          return make_holder_tuple(
-              std::forward<F>(f)(std::forward<T>(x)));
+          return make_holder_tuple(std::forward<F>(f)(std::forward<T>(x)));
         }
       }
     } else {
       if constexpr (InVector) {
         return std::forward<F>(f)(std::forward<T>(x));
       } else {
-        return make_holder_tuple(
-            std::forward<F>(f)(std::forward<T>(x)));
+        return make_holder_tuple(std::forward<F>(f)(std::forward<T>(x)));
       }
     }
   } else {

stan/math/prim/functor/make_holder_tuple.hpp

@@ -33,7 +33,7 @@ struct deduce_cvr {
 
 template <typename T>
 using deduce_cvr_t = typename deduce_cvr<T>::type;
-}
+}  // namespace internal
 /**
  * Holds ownership of rvalues and forwards lvalues into a tuple.
  *
@@ -46,12 +46,12 @@ using deduce_cvr_t = typename deduce_cvr<T>::type;
  * This behavior ensures that temporaries are stored by value in the tuple while
  * lvalues are preserved as references. It is similar in intent to the `Holder`
  * class in behavior, but for tuples instead of Eigen types.
- * It is the opposite of `std::forward_as_tuple`, with the difference in handling rvalues.
- * `std::forward_as_tuple` does not extend object lifetimes, so when an rvalue
- * is passed to `std::forward_as_tuple`, the resulting tuple element will be a
- * reference to a temporary that is destroyed at the end of the statement. This
- * function ensures that rvalues are stored by value in the tuple, extending
- * their lifetimes.
+ * It is the opposite of `std::forward_as_tuple`, with the difference in
+ * handling rvalues. `std::forward_as_tuple` does not extend object lifetimes,
+ * so when an rvalue is passed to `std::forward_as_tuple`, the resulting tuple
+ * element will be a reference to a temporary that is destroyed at the end of
+ * the statement. This function ensures that rvalues are stored by value in the
+ * tuple, extending their lifetimes.
  *
  * @tparam Types Parameter pack representing the types of the arguments.
  * @param args The arguments to forward into the tuple.
@@ -67,7 +67,8 @@ inline constexpr auto make_holder_tuple(Types&&... args) {
   if constexpr (sizeof...(Types) == 0) {
     return std::tuple<>{};
   } else {
-    return std::tuple<internal::deduce_cvr_t<Types&&>...>{std::forward<Types>(args)...};
+    return std::tuple<internal::deduce_cvr_t<Types&&>...>{
+        std::forward<Types>(args)...};
   }
 }
 }  // namespace math

stan/math/prim/functor/tuple_concat.hpp

@@ -23,7 +23,7 @@ inline auto constexpr tuple_concat_impl(Tuple1&& x, Tuple2&& y,
                                         std::index_sequence<I1...> /* i */,
                                         std::index_sequence<I2...> /* j */) {
   return make_holder_tuple(std::get<I1>(std::forward<Tuple1>(x))...,
-                                    std::get<I2>(std::forward<Tuple2>(y))...);
+                           std::get<I2>(std::forward<Tuple2>(y))...);
 }
 
 template <typename Tuple1, typename Tuple2, typename Tuple3, std::size_t... I1,
@@ -33,8 +33,8 @@ inline auto constexpr tuple_concat_impl(Tuple1&& x, Tuple2&& y, Tuple3&& z,
                                         std::index_sequence<I2...> /* j */,
                                         std::index_sequence<I3...> /* k */) {
   return make_holder_tuple(std::get<I1>(std::forward<Tuple1>(x))...,
-                                    std::get<I2>(std::forward<Tuple2>(y))...,
-                                    std::get<I3>(std::forward<Tuple3>(z))...);
+                           std::get<I2>(std::forward<Tuple2>(y))...,
+                           std::get<I3>(std::forward<Tuple3>(z))...);
 }
 }  // namespace internal
 

stan/math/prim/meta/contains_tuple.hpp

@@ -35,7 +35,6 @@ 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>>;
 
-
 }  // namespace stan
 
 #endif

stan/math/rev/core/accumulate_adjoints.hpp

@@ -140,7 +140,6 @@ inline double* accumulate_adjoints(double* dest, Arith&& x, Pargs&&... args) {
   return accumulate_adjoints(dest, std::forward<Pargs>(args)...);
 }
 
-
 }  // namespace math
 }  // namespace stan
 

test/unit/math/mix/functor/hessian_block_diag_test.cpp

@@ -6,8 +6,8 @@ using Eigen::Matrix;
 using Eigen::MatrixXd;
 using Eigen::VectorXd;
 
-using stan::math::hessian_block_diag;
 using stan::math::hessian;
+using stan::math::hessian_block_diag;
 
 namespace hessian_block_diag_test {
 
@@ -24,9 +24,7 @@ struct fun2 {
   template <typename T>
   inline T operator()(const Matrix<T, Dynamic, 1>& x) const {
     using std::sin;
-    return x(0) * x(0) * x(1)
-           + 3.0 * x(1) * x(1)
-           + 5.0 * x(0) * x(1)
+    return x(0) * x(0) * x(1) + 3.0 * x(1) * x(1) + 5.0 * x(0) * x(1)
            + sin(x(0));
   }
 };