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

Author: stan-buildbot

stan/math/opencl/copy.hpp

@@ -98,7 +98,8 @@ inline auto from_matrix_cl(const T& src) {
     try {
       cl::Event copy_event;
       const cl::CommandQueue queue = opencl_context.queue();
-      std::vector<cl::Event> copy_write_events(src.write_events().begin(), src.write_events().end());
+      std::vector<cl::Event> copy_write_events(src.write_events().begin(),
+                                               src.write_events().end());
       queue.enqueueReadBuffer(src.buffer(), opencl_context.in_order(), 0,
                               sizeof(T_val) * dst.size(), dst.data(),
                               &copy_write_events, &copy_event);
@@ -152,7 +153,8 @@ inline T_dst from_matrix_cl(const matrix_cl<T>& src) {
   try {
     cl::Event copy_event;
     const cl::CommandQueue queue = opencl_context.queue();
-      std::vector<cl::Event> copy_write_events(src.write_events().begin(), src.write_events().end());
+    std::vector<cl::Event> copy_write_events(src.write_events().begin(),
+                                             src.write_events().end());
     queue.enqueueReadBuffer(src.buffer(), opencl_context.in_order(), 0,
                             sizeof(T), &dst, &copy_write_events, &copy_event);
     copy_event.wait();
@@ -185,7 +187,8 @@ inline T_dst from_matrix_cl(const matrix_cl<T>& src) {
   try {
     cl::Event copy_event;
     const cl::CommandQueue queue = opencl_context.queue();
-    std::vector<cl::Event> copy_write_events(src.write_events().begin(), src.write_events().end());
+    std::vector<cl::Event> copy_write_events(src.write_events().begin(),
+                                             src.write_events().end());
     queue.enqueueReadBuffer(src.buffer(), opencl_context.in_order(), 0,
                             sizeof(T) * src.rows(), dst.data(),
                             &copy_write_events, &copy_event);
@@ -260,7 +263,8 @@ inline auto packed_copy(const T& src) {
                                      packed, src, src.rows(), src.rows(),
                                      src.view());
     const std::vector<cl::Event> mat_events
-        = vec_concat(std::vector<cl::Event>{}, packed.read_write_events(), src.write_events());
+        = vec_concat(std::vector<cl::Event>{}, packed.read_write_events(),
+                     src.write_events());
     cl::Event copy_event;
     queue.enqueueReadBuffer(packed.buffer(), opencl_context.in_order(), 0,
                             sizeof(T_val) * packed_size, dst.data(),

stan/math/opencl/kernel_cl.hpp

@@ -205,7 +205,8 @@ struct kernel_cl {
       opencl_context.register_kernel_cache(&kernel_);
     }
     cl::EnqueueArgs eargs(opencl_context.queue(),
-                          vec_concat(std::vector<cl::Event>{}, internal::select_events<Args>(args)...),
+                          vec_concat(std::vector<cl::Event>{},
+                                     internal::select_events<Args>(args)...),
                           global_thread_size);
     cl::KernelFunctor<internal::to_const_buffer_t<Args>&...> kernel_functor(
         kernel_);
@@ -232,7 +233,8 @@ struct kernel_cl {
       opencl_context.register_kernel_cache(&kernel_);
     }
     cl::EnqueueArgs eargs(opencl_context.queue(),
-                          vec_concat(std::vector<cl::Event>{}, internal::select_events<Args>(args)...),
+                          vec_concat(std::vector<cl::Event>{},
+                                     internal::select_events<Args>(args)...),
                           global_thread_size, thread_block_size);
     cl::KernelFunctor<internal::to_const_buffer_t<Args>&...> kernel_functor(
         kernel_);

stan/math/opencl/matrix_cl.hpp

@@ -617,19 +617,18 @@ class matrix_cl : public matrix_cl_base {
    */
   void initialize_buffer_cl(const matrix_cl<T>& A) {
     cl::Event cstr_event;
-    std::vector<cl::Event>* dep_events = 
-      new std::vector<cl::Event>(A.write_events().begin(), 
-      A.write_events().end()); 
+    std::vector<cl::Event>* dep_events = new std::vector<cl::Event>(
+        A.write_events().begin(), A.write_events().end());
     try {
       opencl_context.queue().enqueueCopyBuffer(A.buffer(), this->buffer(), 0, 0,
-                                               A.size() * sizeof(T),
-                                               dep_events, &cstr_event);
+                                               A.size() * sizeof(T), dep_events,
+                                               &cstr_event);
       if (opencl_context.device()[0].getInfo<CL_DEVICE_HOST_UNIFIED_MEMORY>()) {
         buffer_cl_.setDestructorCallback(
-          &delete_it_destructor<std::vector<cl::Event>>, dep_events);
+            &delete_it_destructor<std::vector<cl::Event>>, dep_events);
       } else {
-        cstr_event.setCallback(CL_COMPLETE, 
-          &delete_it_event<std::vector<cl::Event>>, dep_events);
+        cstr_event.setCallback(
+            CL_COMPLETE, &delete_it_event<std::vector<cl::Event>>, dep_events);
       }
       this->add_write_event(cstr_event);
       A.add_read_event(cstr_event);

stan/math/opencl/prim/normal_lccdf.hpp

@@ -89,7 +89,8 @@ return_type_t<T_y_cl, T_loc_cl, T_scale_cl> normal_lccdf(
                     calc_if<!is_constant<T_loc_cl>::value>(mu_deriv),
                     calc_if<!is_constant<T_scale_cl>::value>(sigma_deriv));
 
-  T_partials_return lccdf = LOG_HALF * lccdf_cl.size() + sum(from_matrix_cl(lccdf_cl));
+  T_partials_return lccdf
+      = LOG_HALF * lccdf_cl.size() + sum(from_matrix_cl(lccdf_cl));
 
   auto ops_partials = make_partials_propagator(y_col, mu_col, sigma_col);