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

Author: stan-buildbot

stan/math/opencl/kernel_generator/as_operation_cl.hpp

@@ -40,7 +40,8 @@ inline T_operation&& as_operation_cl(T_operation&& a) {
  * @param a scalar
  * @return \c scalar_ wrapping the input
  */
-template <assign_op_cl AssignOp = assign_op_cl::equals, typename T_scalar, typename = require_arithmetic_t<T_scalar>,
+template <assign_op_cl AssignOp = assign_op_cl::equals, typename T_scalar,
+          typename = require_arithmetic_t<T_scalar>,
           require_not_same_t<T_scalar, bool>* = nullptr>
 inline scalar_<T_scalar> as_operation_cl(const T_scalar a) {
   return scalar_<T_scalar>(a);
@@ -55,13 +56,15 @@ inline scalar_<T_scalar> as_operation_cl(const T_scalar a) {
  * @return \c scalar_<char> wrapping the input
  */
 template <assign_op_cl AssignOp = assign_op_cl::equals>
-inline scalar_<char> as_operation_cl(const bool a) { return scalar_<char>(a); }
+inline scalar_<char> as_operation_cl(const bool a) {
+  return scalar_<char>(a);
+}
 
 /**
  * Converts any valid kernel generator expression into an operation. This is an
  * overload for \c matrix_cl. It wraps them into into \c load_.
- * @tparam AssignOp an optional `assign_op_cl` that dictates whether the object 
- *  is assigned using standard or compound assign. 
+ * @tparam AssignOp an optional `assign_op_cl` that dictates whether the object
+ *  is assigned using standard or compound assign.
  * @tparam T_matrix_cl \c matrix_cl
  * @param a \c matrix_cl
  * @return \c load_ wrapping the input
@@ -80,15 +83,16 @@ inline load_<T_matrix_cl, AssignOp> as_operation_cl(T_matrix_cl&& a) {
  * as_operation_cl_t<T>. If the return value of \c as_operation_cl() would be a
  * rvalue reference, the reference is removed, so that a variable of this type
  * actually stores the value.
- * @tparam T a `matrix_cl` or `Scalar` type 
- * @tparam AssignOp an optional `assign_op_cl` that dictates whether the object 
- *  is assigned using standard or compound assign. 
+ * @tparam T a `matrix_cl` or `Scalar` type
+ * @tparam AssignOp an optional `assign_op_cl` that dictates whether the object
+ *  is assigned using standard or compound assign.
  */
 template <typename T, assign_op_cl AssignOp = assign_op_cl::equals>
-using as_operation_cl_t = std::conditional_t<
-    std::is_lvalue_reference<T>::value,
-    decltype(as_operation_cl<AssignOp>(std::declval<T>())),
-    std::remove_reference_t<decltype(as_operation_cl<AssignOp>(std::declval<T>()))>>;
+using as_operation_cl_t
+    = std::conditional_t<std::is_lvalue_reference<T>::value,
+                         decltype(as_operation_cl<AssignOp>(std::declval<T>())),
+                         std::remove_reference_t<decltype(
+                             as_operation_cl<AssignOp>(std::declval<T>()))>>;
 
 /** @}*/
 }  // namespace math

stan/math/opencl/kernel_generator/assignment_ops.hpp

@@ -9,11 +9,18 @@ namespace math {
 /**
  * Ops that decide the type of assignment for LHS operations
  */
-enum class assign_op_cl {equals, plus_equals, minus_equals, divide_equals, multiply_equals};
+enum class assign_op_cl {
+  equals,
+  plus_equals,
+  minus_equals,
+  divide_equals,
+  multiply_equals
+};
 
 namespace internal {
 /**
- * @param value A static constexpr const char* member for printing assignment ops
+ * @param value A static constexpr const char* member for printing assignment
+ * ops
  */
 template <assign_op_cl assign_op>
 struct assignment_op_str_impl;
@@ -47,11 +54,11 @@ template <typename, typename = void>
 struct assignment_op_str : assignment_op_str_impl<assign_op_cl::equals> {};
 
 template <typename T>
-struct assignment_op_str<T, void_t<decltype(T::assignment_op)>> : assignment_op_str_impl<T::assignment_op> {};
+struct assignment_op_str<T, void_t<decltype(T::assignment_op)>>
+    : assignment_op_str_impl<T::assignment_op> {};
 
 }  // namespace internal
 
-
 /**
  * @tparam T A type that has an `assignment_op` static constexpr member type
  * @return The types assignment op as a constexpr const char*
@@ -61,7 +68,7 @@ inline constexpr const char* assignment_op() noexcept {
   return internal::assignment_op_str<std::decay_t<T>>::value;
 }
 
-}
-}
+}  // namespace math
+}  // namespace stan
 #endif
 #endif

stan/math/opencl/kernel_generator/load.hpp

@@ -25,7 +25,8 @@ namespace math {
 /**
  * Represents an access to a \c matrix_cl in kernel generator expressions
  * @tparam T \c matrix_cl
- * @tparam AssignOp tells higher level operations whether the final operation should be an assignment or a type of compound assignment.
+ * @tparam AssignOp tells higher level operations whether the final operation
+ * should be an assignment or a type of compound assignment.
  */
 template <typename T, assign_op_cl AssignOp = assign_op_cl::equals>
 class load_
@@ -35,7 +36,6 @@ class load_
   T a_;
 
  public:
-
   static constexpr assign_op_cl assignment_op = AssignOp;
   using Scalar = typename std::remove_reference_t<T>::type;
   using base = operation_cl<load_<T, AssignOp>, Scalar>;
@@ -57,8 +57,12 @@ class load_
    * @return copy of \c *this
    */
   inline load_<T&, AssignOp> deep_copy() & { return load_<T&, AssignOp>(a_); }
-  inline load_<const T&, AssignOp> deep_copy() const& { return load_<const T&, AssignOp>(a_); }
-  inline load_<T, AssignOp> deep_copy() && { return load_<T, AssignOp>(std::forward<T>(a_)); }
+  inline load_<const T&, AssignOp> deep_copy() const& {
+    return load_<const T&, AssignOp>(a_);
+  }
+  inline load_<T, AssignOp> deep_copy() && {
+    return load_<T, AssignOp>(std::forward<T>(a_));
+  }
 
   /**
    * Generates kernel code for this expression.

stan/math/opencl/kernel_generator/multi_result_kernel.hpp

@@ -323,16 +323,17 @@ class results_cl {
     });
   }
 
-    /**
+  /**
    * Incrementing \c results_ object by \c expressions_cl object
    * executes the kernel that evaluates expressions and increments results by
    * those expressions.
-   * @tparam AssignOp an optional `assign_op_cl` that dictates whether the object 
-   *  is assigned using standard or compound assign. 
+   * @tparam AssignOp an optional `assign_op_cl` that dictates whether the
+   * object is assigned using standard or compound assign.
    * @tparam T_expressions types of expressions
    * @param exprs expressions
    */
-  template <assign_op_cl AssignOp = assign_op_cl::plus_equals, typename... T_expressions,
+  template <assign_op_cl AssignOp = assign_op_cl::plus_equals,
+            typename... T_expressions,
             typename = std::enable_if_t<sizeof...(T_results)
                                         == sizeof...(T_expressions)>>
   void compound_assignment_impl(const expressions_cl<T_expressions...>& exprs) {
@@ -361,7 +362,7 @@ class results_cl {
     compound_assignment_impl<assign_op_cl::plus_equals>(exprs);
   }
 
-    /**
+  /**
    * Decrement \c results_ object by \c expressions_cl object
    * executes the kernel that evaluates expressions and increments results by
    * those expressions.
@@ -375,7 +376,7 @@ class results_cl {
     compound_assignment_impl<assign_op_cl::minus_equals>(exprs);
   }
 
-    /**
+  /**
    * Elementwise divide \c results_ object by \c expressions_cl object
    * executes the kernel that evaluates expressions and increments results by
    * those expressions.
@@ -389,7 +390,7 @@ class results_cl {
     compound_assignment_impl<assign_op_cl::divide_equals>(exprs);
   }
 
-    /**
+  /**
    * Elementwise multiply \c results_ object by \c expressions_cl object
    * executes the kernel that evaluates expressions and increments results by
    * those expressions.
@@ -484,7 +485,7 @@ class results_cl {
           + parts.reduction_2d +
           "}\n";
     }
-     return src;
+    return src;
   }
 
   /**
@@ -583,38 +584,44 @@ class results_cl {
   /**
    * Makes a std::pair of one result and one expression and wraps it into a
    * tuple.
-   * @tparam AssignOp an optional `assign_op_cl` that dictates whether the object 
-   *  is assigned using standard or compound assign. 
-   * @tparam T_result An non scalar type that is normally an `result_cl` operation holding a `matrix_cl` 
-   * @tparam T_expression An expression of set of operations on `matrix_cl` and scalar types.
+   * @tparam AssignOp an optional `assign_op_cl` that dictates whether the
+   * object is assigned using standard or compound assign.
+   * @tparam T_result An non scalar type that is normally an `result_cl`
+   * operation holding a `matrix_cl`
+   * @tparam T_expression An expression of set of operations on `matrix_cl` and
+   * scalar types.
    * @param result result
    * @param expression expression
    * @return a tuple of pair of result and expression
    */
-  template <assign_op_cl AssignOp = assign_op_cl::equals, typename T_result, typename T_expression,
+  template <assign_op_cl AssignOp = assign_op_cl::equals, typename T_result,
+            typename T_expression,
             require_all_not_t<is_without_output<T_expression>,
                               conjunction<internal::is_scalar_check<T_result>,
                                           std::is_arithmetic<std::decay_t<
                                               T_expression>>>>* = nullptr>
   static auto make_assignment_pair(T_result&& result,
                                    T_expression&& expression) {
-    return std::make_tuple(
-        std::pair<as_operation_cl_t<T_result, AssignOp>, as_operation_cl_t<T_expression>>(
-            as_operation_cl<AssignOp>(std::forward<T_result>(result)),
-            as_operation_cl(std::forward<T_expression>(expression))));
+    return std::make_tuple(std::pair<as_operation_cl_t<T_result, AssignOp>,
+                                     as_operation_cl_t<T_expression>>(
+        as_operation_cl<AssignOp>(std::forward<T_result>(result)),
+        as_operation_cl(std::forward<T_expression>(expression))));
   }
 
   /**
    * If an expression does not need to be calculated this returns an empty tuple
-   * @tparam AssignOp an optional `assign_op_cl` that dictates whether the object 
-   *  is assigned using standard or compound assign. 
-   * @tparam T_result An non scalar type that is normally an `result_cl` operation holding a `matrix_cl` 
-   * @tparam T_expression An expression of set of operations on `matrix_cl` and scalar types.
+   * @tparam AssignOp an optional `assign_op_cl` that dictates whether the
+   * object is assigned using standard or compound assign.
+   * @tparam T_result An non scalar type that is normally an `result_cl`
+   * operation holding a `matrix_cl`
+   * @tparam T_expression An expression of set of operations on `matrix_cl` and
+   * scalar types.
    * @param result result
    * @param expression expression
    * @return a tuple of pair of result and expression
    */
-  template <assign_op_cl AssignOp = assign_op_cl::equals, typename T_result, typename T_expression,
+  template <assign_op_cl AssignOp = assign_op_cl::equals, typename T_result,
+            typename T_expression,
             require_t<is_without_output<T_expression>>* = nullptr>
   static auto make_assignment_pair(T_result&& result,
                                    T_expression&& expression) {
@@ -624,15 +631,16 @@ class results_cl {
   /**
    * Checks on scalars are done separately in this overload instead of in
    * kernel.
-   * @tparam AssignOp an optional `assign_op_cl` that dictates whether the object 
-   *  is assigned using standard or compound assign. 
+   * @tparam AssignOp an optional `assign_op_cl` that dictates whether the
+   * object is assigned using standard or compound assign.
    * @tparam T_check A scalar type
    * @tparam T_pass An integral type
    * @param result result - check
    * @param pass bool scalar
    * @return an empty tuple
    */
-  template <assign_op_cl AssignOp = assign_op_cl::equals, typename T_check, typename T_pass,
+  template <assign_op_cl AssignOp = assign_op_cl::equals, typename T_check,
+            typename T_pass,
             require_t<internal::is_scalar_check<T_check>>* = nullptr,
             require_integral_t<T_pass>* = nullptr>
   static std::tuple<> make_assignment_pair(T_check&& result, T_pass&& pass) {

stan/math/opencl/kernel_generator/operation_cl.hpp

@@ -76,21 +76,21 @@ struct kernel_parts {
 };
 
 std::ostream& operator<<(std::ostream& os, kernel_parts& parts) {
-      os << "args:" << std::endl;
-      os <<                parts.args.substr(0, parts.args.size() - 2)  << std::endl;
-      os << "Decl:" << std::endl;
-           os << parts.declarations << std::endl;
-           os << "Init:" << std::endl;
-           os << parts.initialization << std::endl;
-           os << "body:" << std::endl;
-           os << parts.body << std::endl;
-           os << "body_suffix:" << std::endl;
-           os << parts.body_suffix << std::endl;
-           os << "reduction_1d:" << std::endl;
-           os << parts.reduction_1d << std::endl;
-           os << "reduction_2d:" << std::endl;
-           os << parts.reduction_2d << std::endl;
-    return os;
+  os << "args:" << std::endl;
+  os << parts.args.substr(0, parts.args.size() - 2) << std::endl;
+  os << "Decl:" << std::endl;
+  os << parts.declarations << std::endl;
+  os << "Init:" << std::endl;
+  os << parts.initialization << std::endl;
+  os << "body:" << std::endl;
+  os << parts.body << std::endl;
+  os << "body_suffix:" << std::endl;
+  os << parts.body_suffix << std::endl;
+  os << "reduction_1d:" << std::endl;
+  os << parts.reduction_1d << std::endl;
+  os << "reduction_2d:" << std::endl;
+  os << parts.reduction_2d << std::endl;
+  return os;
 }
 
 /**

stan/math/opencl/rev/adjoint_results.hpp

@@ -41,21 +41,24 @@ class adjoint_results_cl : protected results_cl<T_results...> {
     index_apply<sizeof...(T_expressions)>([&](auto... Is) {
       auto scalars = std::tuple_cat(select_scalar_assignments(
           std::get<Is>(this->results_), std::get<Is>(exprs.expressions_))...);
-      auto nonscalars_tmp = std::tuple_cat(select_nonscalar_assignments<assign_op_cl::plus_equals>(
-          std::get<Is>(this->results_), std::get<Is>(exprs.expressions_))...);
+      auto nonscalars_tmp = std::tuple_cat(
+          select_nonscalar_assignments<assign_op_cl::plus_equals>(
+              std::get<Is>(this->results_),
+              std::get<Is>(exprs.expressions_))...);
 
       index_apply<std::tuple_size<decltype(nonscalars_tmp)>::value>(
           [&](auto... Is_nonscal) {
-            auto nonscalars = std::make_tuple(std::make_pair(
-                std::get<Is_nonscal>(nonscalars_tmp).first, std::get<Is_nonscal>(nonscalars_tmp).second)...);
- 
- 
+            auto nonscalars = std::make_tuple(
+                std::make_pair(std::get<Is_nonscal>(nonscalars_tmp).first,
+                               std::get<Is_nonscal>(nonscalars_tmp).second)...);
+
             index_apply<std::tuple_size<decltype(scalars)>::value>(
                 [&](auto... Is_scal) {
                   // evaluate all expressions
                   this->assignment_impl(std::tuple_cat(
                       nonscalars,
-                      this->template make_assignment_pair<assign_op_cl::plus_equals>(
+                      this->template make_assignment_pair<
+                          assign_op_cl::plus_equals>(
                           std::get<2>(std::get<Is_scal>(scalars)),
                           sum_2d(std::get<1>(std::get<Is_scal>(scalars))))...));
 
@@ -99,11 +102,10 @@ class adjoint_results_cl : protected results_cl<T_results...> {
     return std::make_tuple();
   }
 
-
   /**
    * Selects assignments that have non-scalar var results.
-   * @tparam AssignOp an optional `assign_op_cl` that dictates whether the object 
-   *  is assigned using standard or compound assign. 
+   * @tparam AssignOp an optional `assign_op_cl` that dictates whether the
+   * object is assigned using standard or compound assign.
    * @tparam T_result type of result. This overload is used for non-scalar vars.
    * @tparam T_expression type of expression
    * @param result result
@@ -121,17 +123,17 @@ class adjoint_results_cl : protected results_cl<T_results...> {
   }
   /**
    * Selects assignments that have non-scalar var results.
-   * @tparam AssignOp an optional `assign_op_cl` that dictates whether the object 
-   *  is assigned using standard or compound assign. 
+   * @tparam AssignOp an optional `assign_op_cl` that dictates whether the
+   * object is assigned using standard or compound assign.
    * @tparam T_result type of result. This overload is used for results that are
    * either scalars or not vars.
    * @tparam T_expression type of expression
    * @param result result
    * @param expression expression
    * @return empty tuple
    */
-  template <assign_op_cl AssignOp,
-      typename T_result, typename T_expression,
+  template <
+      assign_op_cl AssignOp, typename T_result, typename T_expression,
       std::enable_if_t<is_stan_scalar<T_result>::value
                        || !is_var<scalar_type_t<T_result>>::value>* = nullptr>
   auto select_nonscalar_assignments(T_result&& result,

stan/math/opencl/rev/grad.hpp

@@ -19,8 +19,7 @@ namespace math {
  * @param[in] x Variables being differentiated with respect to
  * @param[out] g Gradient, d/dx v, evaluated at x.
  */
-inline void grad(var& v, var_value<matrix_cl<double>>& x,
-                 Eigen::VectorXd& g) {
+inline void grad(var& v, var_value<matrix_cl<double>>& x, Eigen::VectorXd& g) {
   grad(v.vi_);
   g = from_matrix_cl<Eigen::VectorXd>(x.adj());
 }