[Jenkins] auto-formatting by clang-format version 6.0.1-14 (tags/RELEASE_601/final)

Author: stan-buildbot

stan/math/opencl/kernel_generator/multi_result_kernel.hpp

@@ -219,7 +219,7 @@ class expressions_cl {
    */
   explicit expressions_cl(T_expressions&&... expressions)
       : expressions_(
-          T_expressions(std::forward<T_expressions>(expressions))...) {}
+            T_expressions(std::forward<T_expressions>(expressions))...) {}
 
  private:
   std::tuple<T_expressions...> expressions_;
@@ -372,7 +372,8 @@ class results_cl {
    */
   template <typename... T_expressions, size_t... Is>
   void assignment(const expressions_cl<T_expressions...>& exprs,
-                  std::index_sequence<Is...>) {;
+                  std::index_sequence<Is...>) {
+    ;
     assignment_impl(std::tuple_cat(make_assignment_pair(
         as_operation_cl(std::get<Is>(results_)),
         as_operation_cl(std::get<Is>(exprs.expressions_)))...));
@@ -486,8 +487,8 @@ class results_cl {
    * @return an empty tuple
    */
   template <typename Scal>
-  static std::tuple<> make_assignment_pair(
-      check_cl_<scalar_<Scal>>& result, scalar_<char> expression) {
+  static std::tuple<> make_assignment_pair(check_cl_<scalar_<Scal>>& result,
+                                           scalar_<char> expression) {
     if (!expression.a_) {
       std::stringstream s;
       s << result.function_ << ": " << result.err_variable_ << " = "

stan/math/opencl/kernel_generator/operation_cl.hpp

@@ -132,16 +132,14 @@ class operation_cl : public operation_cl_base {
     int cols = derived().cols();
     const char* function = "operation_cl.eval()";
     if (rows < 0) {
-      invalid_argument(
-          function, "Number of rows of expression", rows,
-          " must be nonnegative, but is ",
-          " (broadcasted expressions can not be evaluated)");
+      invalid_argument(function, "Number of rows of expression", rows,
+                       " must be nonnegative, but is ",
+                       " (broadcasted expressions can not be evaluated)");
     }
     if (cols < 0) {
-      invalid_argument(
-          function, "Number of columns of expression", cols,
-          " must be nonnegative, but is ",
-          " (broadcasted expressions can not be evaluated)");
+      invalid_argument(function, "Number of columns of expression", cols,
+                       " must be nonnegative, but is ",
+                       " (broadcasted expressions can not be evaluated)");
     }
     matrix_cl<Scalar> res(rows, cols, derived().view());
     if (res.size() > 0) {
@@ -228,7 +226,7 @@ class operation_cl : public operation_cl_base {
             generated, name_gen, row_index_name_arg, col_index_name_arg,
             view_handled
                 && std::tuple_element_t<
-                    Is, typename Deriv::view_transitivity>::value)...};
+                       Is, typename Deriv::view_transitivity>::value)...};
       });
       res = std::accumulate(args_parts.begin(), args_parts.end(),
                             kernel_parts{});

stan/math/opencl/kernel_generator/operation_cl_lhs.hpp

@@ -82,8 +82,7 @@ class operation_cl_lhs : public operation_cl<Derived, Scalar, Args...>,
   template <typename T_expression,
             typename
             = require_all_kernel_expressions_and_none_scalar_t<T_expression>>
-  operation_cl_lhs<Derived, Scalar, Args...>& operator=(
-      T_expression&& rhs) {
+  operation_cl_lhs<Derived, Scalar, Args...>& operator=(T_expression&& rhs) {
     auto expression
         = as_operation_cl(std::forward<T_expression>(rhs)).derived();
     int this_rows = derived().rows();

test/unit/math/opencl/kernel_generator/check_cl_test.cpp

@@ -21,14 +21,12 @@ TEST(KernelGenerator, check_cl_error) {
 }
 
 TEST(KernelGenerator, check_cl_scalar_check_only_pass) {
-  EXPECT_NO_THROW(
-      stan::math::check_cl("test", "m1", 3, "positive") = 3 > 0);
+  EXPECT_NO_THROW(stan::math::check_cl("test", "m1", 3, "positive") = 3 > 0);
 }
 
 TEST(KernelGenerator, check_cl_scalar_check_only_throw) {
-  EXPECT_THROW(
-      stan::math::check_cl("test", "m1", 0, "positive") = 0 > 0,
-      std::domain_error);
+  EXPECT_THROW(stan::math::check_cl("test", "m1", 0, "positive") = 0 > 0,
+               std::domain_error);
 }
 
 TEST(KernelGenerator, check_cl_check_only_pass) {