[Jenkins] auto-formatting by clang-format version 6.0.0

Author: stan-buildbot

stan/math/fwd/functor/reduce_sum.hpp

@@ -73,8 +73,7 @@ struct reduce_sum_impl {
     }
 
     if (auto_partitioning) {
-      return ReduceFunction()(std::forward<Vec>(vmapped),
-                              0, vmapped.size() - 1,
+      return ReduceFunction()(std::forward<Vec>(vmapped), 0, vmapped.size() - 1,
                               msgs, std::forward<Args>(args)...);
     } else {
       return_type_t<Vec, Args...> sum = 0.0;
@@ -89,8 +88,8 @@ struct reduce_sum_impl {
           sub_slice.emplace_back(vmapped[i]);
         }
 
-        sum += ReduceFunction()(std::forward<Vec>(sub_slice), start, end, 
-                                msgs, std::forward<Args>(args)...);
+        sum += ReduceFunction()(std::forward<Vec>(sub_slice), start, end, msgs,
+                                std::forward<Args>(args)...);
       }
       return sum;
     }

stan/math/rev/functor/reduce_sum.hpp

@@ -116,8 +116,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
       // Perform calculation
       var sub_sum_v = apply(
           [&](auto&&... args) {
-            return ReduceFunction()(local_sub_slice,
-                                    r.begin(), r.end() - 1,
+            return ReduceFunction()(local_sub_slice, r.begin(), r.end() - 1,
                                     msgs_, args...);
           },
           args_tuple_local_copy);

test/unit/math/prim/functor/reduce_sum_test.cpp

@@ -237,8 +237,8 @@ TEST(StanMathPrim_reduce_sum, sum) {
 std::vector<int> threading_test_global;
 struct threading_test_lpdf {
   template <typename T1>
-  inline auto operator()(const std::vector<T1>&, std::size_t start, std::size_t end,
-                         std::ostream* msgs) const {
+  inline auto operator()(const std::vector<T1>&, std::size_t start,
+                         std::size_t end, std::ostream* msgs) const {
     threading_test_global[start] = tbb::this_task_arena::current_thread_index();
 
     return stan::return_type_t<T1>(0);

test/unit/math/prim/functor/reduce_sum_util.hpp

@@ -21,9 +21,8 @@ struct count_lpdf {
   count_lpdf() {}
 
   // does the reduction in the sub-slice start to end
-  inline T operator()(const std::vector<int>& sub_slice,
-                      std::size_t start, std::size_t end,
-                      std::ostream* msgs,
+  inline T operator()(const std::vector<int>& sub_slice, std::size_t start,
+                      std::size_t end, std::ostream* msgs,
                       const std::vector<T>& lambda,
                       const std::vector<int>& idata) const {
     return stan::math::poisson_lpmf(sub_slice, lambda[0]);
@@ -35,8 +34,8 @@ struct nesting_count_lpdf {
   nesting_count_lpdf() {}
 
   // does the reduction in the sub-slice start to end
-  inline T operator()(const std::vector<int>& sub_slice,
-                      std::size_t start, std::size_t end, std::ostream* msgs,
+  inline T operator()(const std::vector<int>& sub_slice, std::size_t start,
+                      std::size_t end, std::ostream* msgs,
                       const std::vector<T>& lambda,
                       const std::vector<int>& idata) const {
     return stan::math::reduce_sum<count_lpdf<T>>(sub_slice, 5, msgs, lambda,
@@ -98,9 +97,8 @@ struct slice_group_count_lpdf {
   slice_group_count_lpdf() {}
 
   // does the reduction in the sub-slice start to end
-  inline T operator()(const std::vector<T>& lambda_slice,
-                      std::size_t start, std::size_t end,
-                      std::ostream* msgs,
+  inline T operator()(const std::vector<T>& lambda_slice, std::size_t start,
+                      std::size_t end, std::ostream* msgs,
                       const std::vector<int>& y,
                       const std::vector<int>& gsidx) const {
     const std::size_t num_groups = end - start + 1;
@@ -170,8 +168,9 @@ auto reduce_sum_sum_lpdf = [](auto&& data, auto&&... args) {
 template <int grainsize>
 struct static_check_lpdf {
   template <typename T>
-  inline auto operator()(const std::vector<int>&, std::size_t start, std::size_t end,
-                         std::ostream* msgs, const std::vector<T>& data) const {
+  inline auto operator()(const std::vector<int>&, std::size_t start,
+                         std::size_t end, std::ostream* msgs,
+                         const std::vector<T>& data) const {
     T sum = 0;
     EXPECT_LE(end - start + 1, grainsize);
     for (size_t i = start; i <= end; i++) {