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

stan/math/fwd/functor/fvar_finite_diff.hpp

@@ -22,7 +22,7 @@ namespace internal {
  * @tparam InputArgT Type of the function input argument
  * @param tangent Calculated tangent
  * @param arg Input argument
-*/
+ */
 template <typename FuncTangentT, typename InputArgT,
           require_not_st_fvar<InputArgT>* = nullptr>
 inline constexpr double aggregate_tangent(const FuncTangentT& tangent,
@@ -41,13 +41,13 @@ inline constexpr double aggregate_tangent(const FuncTangentT& tangent,
  * @tparam InputArgT Type of the function input argument
  * @param tangent Calculated tangent
  * @param arg Input argument
-*/
+ */
 template <typename FuncTangentT, typename InputArgT,
           require_st_fvar<InputArgT>* = nullptr>
 auto aggregate_tangent(const FuncTangentT& tangent, const InputArgT& arg) {
   return sum(elt_multiply(tangent, arg.d()));
 }
-}
+}  // namespace internal
 
 /**
  * This frameworks adds fvar<T> support for arbitrary functions through
@@ -59,7 +59,7 @@ auto aggregate_tangent(const FuncTangentT& tangent, const InputArgT& arg) {
  *                     to be passed to function
  * @param func Functor for which fvar<T> support is needed
  * @param args... Parameter pack of arguments to be passed to functor.
-*/
+ */
 template <typename F, typename... TArgs,
           require_any_st_fvar<TArgs...>* = nullptr>
 auto fvar_finite_diff(const F& func, const TArgs&... args) {
@@ -69,17 +69,20 @@ auto fvar_finite_diff(const F& func, const TArgs&... args) {
   auto val_args = std::make_tuple(stan::math::value_of(args)...);
 
   auto serialised_args = stan::math::apply(
-    [&](auto&&... tuple_args) {
-      return math::to_vector(stan::test::serialize<FvarInnerT>(tuple_args...));
-    }, val_args);
+      [&](auto&&... tuple_args) {
+        return math::to_vector(
+            stan::test::serialize<FvarInnerT>(tuple_args...));
+      },
+      val_args);
 
   // Create a 'wrapper' functor which will take the flattened column-vector
   // and transform it to individual arguments which are passed to the
   // user-provided functor
   auto serial_functor = [&](const auto& v) {
     auto ds = stan::test::to_deserializer(v);
-    return stan::math::apply([&](auto&&... tuple_args) {
-      return func(ds.read(tuple_args)...); }, val_args);
+    return stan::math::apply(
+        [&](auto&&... tuple_args) { return func(ds.read(tuple_args)...); },
+        val_args);
   };
 
   FvarInnerT rtn_value;
@@ -89,9 +92,8 @@ auto fvar_finite_diff(const F& func, const TArgs&... args) {
   auto ds_grad = stan::test::to_deserializer(grad);
   FvarInnerT rtn_grad = 0;
   // Use a fold-expression to aggregate tangents for input arguments
-  (void)std::initializer_list<int>{
-    (rtn_grad += internal::aggregate_tangent(ds_grad.read(args), args), 0)...
-  };
+  (void)std::initializer_list<int>{(
+      rtn_grad += internal::aggregate_tangent(ds_grad.read(args), args), 0)...};
 
   return fvar<FvarInnerT>(rtn_value, rtn_grad);
 }
@@ -108,7 +110,7 @@ auto fvar_finite_diff(const F& func, const TArgs&... args) {
  * @tparam TArgs... Types of arguments (containing no fvar<T> types)
  * @param func Functor
  * @param args... Parameter pack of arguments to be passed to functor.
-*/
+ */
 template <typename F, typename... TArgs,
           require_all_not_st_fvar<TArgs...>* = nullptr>
 auto fvar_finite_diff(const F& func, const TArgs&... args) {

stan/math/fwd/functor/integrate_1d.hpp

@@ -38,24 +38,30 @@ inline return_type_t<T_a, T_b, Args...> integrate_1d_impl(
   auto a_val = value_of(a);
   auto b_val = value_of(b);
   auto func
-    = [f, msgs, relative_tolerance, a_val, b_val](const auto&... args_var) {
-    return integrate_1d_impl(f, a_val, b_val, relative_tolerance, msgs,
-                               args_var...);
-  };
+      = [f, msgs, relative_tolerance, a_val, b_val](const auto &... args_var) {
+          return integrate_1d_impl(f, a_val, b_val, relative_tolerance, msgs,
+                                   args_var...);
+        };
   FvarT ret = fvar_finite_diff(func, args...);
 
   // Calculate tangents w.r.t. integration bounds if needed
   if (is_fvar<T_a>::value || is_fvar<T_b>::value) {
     auto val_args = std::make_tuple(value_of(args)...);
     if (is_fvar<T_a>::value) {
-      ret.d_ += math::forward_as<FvarT>(a).d_ *
-        math::apply([&](auto&&... tuple_args) {
-          return -f(a_val, 0.0, msgs, tuple_args...); }, val_args);
+      ret.d_ += math::forward_as<FvarT>(a).d_
+                * math::apply(
+                    [&](auto &&... tuple_args) {
+                      return -f(a_val, 0.0, msgs, tuple_args...);
+                    },
+                    val_args);
     }
     if (is_fvar<T_b>::value) {
-      ret.d_ += math::forward_as<FvarT>(b).d_ *
-        math::apply([&](auto&&... tuple_args) {
-          return f(b_val, 0.0, msgs, tuple_args...); }, val_args);
+      ret.d_ += math::forward_as<FvarT>(b).d_
+                * math::apply(
+                    [&](auto &&... tuple_args) {
+                      return f(b_val, 0.0, msgs, tuple_args...);
+                    },
+                    val_args);
     }
   }
   return ret;

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

@@ -3,13 +3,13 @@
 TEST(mixFunctor, integrate1D) {
   auto f = [&](const auto& x_input) {
     auto func = [](const auto& x, const auto& xc, std::ostream* msgs,
-                    const auto& theta) {
+                   const auto& theta) {
       return stan::math::exp(theta * stan::math::cos(2 * 3.141593 * x)) + theta;
     };
     const double relative_tolerance = std::sqrt(stan::math::EPSILON);
-    std::ostringstream *msgs = nullptr;
+    std::ostringstream* msgs = nullptr;
     return stan::math::integrate_1d_impl(func, 0, 1, relative_tolerance, msgs,
-                                          x_input);
+                                         x_input);
   };
   stan::test::expect_ad(f, 0.75);
   stan::test::expect_ad(f, 0.2);