[Jenkins] auto-formatting by clang-format version 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

Author: stan-buildbot

stan/math/fwd/fun/Eigen_NumTraits.hpp

@@ -143,8 +143,7 @@ struct ScalarBinaryOpTraits<std::complex<stan::math::fvar<T>>, double,
  * defined
  */
 template <typename T, typename BinaryOp>
-struct ScalarBinaryOpTraits<int, std::complex<stan::math::fvar<T>>,
-                            BinaryOp> {
+struct ScalarBinaryOpTraits<int, std::complex<stan::math::fvar<T>>, BinaryOp> {
   using ReturnType = std::complex<stan::math::fvar<T>>;
 };
 
@@ -157,8 +156,7 @@ struct ScalarBinaryOpTraits<int, std::complex<stan::math::fvar<T>>,
  * defined
  */
 template <typename T, typename BinaryOp>
-struct ScalarBinaryOpTraits<std::complex<stan::math::fvar<T>>, int,
-                            BinaryOp> {
+struct ScalarBinaryOpTraits<std::complex<stan::math::fvar<T>>, int, BinaryOp> {
   using ReturnType = std::complex<stan::math::fvar<T>>;
 };
 

stan/math/prim/fun/Eigen.hpp

@@ -24,57 +24,56 @@
 #include <Eigen/QR>
 #include <Eigen/src/Core/NumTraits.h>
 
-namespace Eigen {
+    namespace Eigen {
 
-/**
- * Traits specialization for Eigen binary operations for `int`
- * and `double` arguments.
- *
- * @tparam BinaryOp type of binary operation for which traits are
- * defined
- */
-template <typename BinaryOp>
-struct ScalarBinaryOpTraits<int, double, BinaryOp> {
-  using ReturnType = double;
-};
+  /**
+   * Traits specialization for Eigen binary operations for `int`
+   * and `double` arguments.
+   *
+   * @tparam BinaryOp type of binary operation for which traits are
+   * defined
+   */
+  template <typename BinaryOp>
+  struct ScalarBinaryOpTraits<int, double, BinaryOp> {
+    using ReturnType = double;
+  };
 
-/**
- * Traits specialization for Eigen binary operations for `double`
- * and `int` arguments.
- *
- * @tparam BinaryOp type of binary operation for which traits are
- * defined
- */
-template <typename BinaryOp>
-struct ScalarBinaryOpTraits<double, int, BinaryOp> {
-  using ReturnType = double;
-};
+  /**
+   * Traits specialization for Eigen binary operations for `double`
+   * and `int` arguments.
+   *
+   * @tparam BinaryOp type of binary operation for which traits are
+   * defined
+   */
+  template <typename BinaryOp>
+  struct ScalarBinaryOpTraits<double, int, BinaryOp> {
+    using ReturnType = double;
+  };
 
-/**
- * Traits specialization for Eigen binary operations for `int`
- * and complex `double` arguments.
- *
- * @tparam BinaryOp type of binary operation for which traits are
- * defined
- */
-template <typename BinaryOp>
-struct ScalarBinaryOpTraits<int, std::complex<double>, BinaryOp> {
-  using ReturnType = std::complex<double>;
-};
+  /**
+   * Traits specialization for Eigen binary operations for `int`
+   * and complex `double` arguments.
+   *
+   * @tparam BinaryOp type of binary operation for which traits are
+   * defined
+   */
+  template <typename BinaryOp>
+  struct ScalarBinaryOpTraits<int, std::complex<double>, BinaryOp> {
+    using ReturnType = std::complex<double>;
+  };
 
+  /**
+   * Traits specialization for Eigen binary operations for complex
+   * `double` and `int` arguments.
+   *
+   * @tparam BinaryOp type of binary operation for which traits are
+   * defined
+   */
+  template <typename BinaryOp>
+  struct ScalarBinaryOpTraits<std::complex<double>, int, BinaryOp> {
+    using ReturnType = std::complex<double>;
+  };
 
-/**
- * Traits specialization for Eigen binary operations for complex
- * `double` and `int` arguments.
- *
- * @tparam BinaryOp type of binary operation for which traits are
- * defined
- */
-template <typename BinaryOp>
-struct ScalarBinaryOpTraits<std::complex<double>, int, BinaryOp> {
-  using ReturnType = std::complex<double>;
-};
-
-}
+}  // namespace Eigen
 
 #endif

stan/math/prim/fun/bessel_first_kind.hpp

@@ -53,9 +53,9 @@ inline T2 bessel_first_kind(int v, const T2 z) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto bessel_first_kind(const T1& a, const T2& b) {
-  return apply_scalar_binary(
-      a, b, [&](const auto& c, const auto& d) {
-        return bessel_first_kind(c, d); });
+  return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
+    return bessel_first_kind(c, d);
+  });
 }
 
 }  // namespace math

stan/math/prim/fun/falling_factorial.hpp

@@ -80,9 +80,9 @@ inline return_type_t<T> falling_factorial(const T& x, int n) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto falling_factorial(const T1& a, const T2& b) {
-  return apply_scalar_binary(
-      a, b, [&](const auto& c, const auto& d) {
-        return falling_factorial(c, d); });
+  return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
+    return falling_factorial(c, d);
+  });
 }
 
 }  // namespace math

test/unit/math/test_ad.hpp

@@ -1331,10 +1331,8 @@ template <typename F, typename T1, typename T2,
           require_st_integral<T1>* = nullptr>
 void expect_ad_vectorized_binary_impl(const ad_tolerances& tols, const F& f,
                                       const T1& x, const T2& y) {
-  auto f_bind = [&](const auto& x) {
-    return
-        [=](const auto& y) { return f(x, y); };
-  };
+  auto f_bind
+      = [&](const auto& x) { return [=](const auto& y) { return f(x, y); }; };
   std::vector<T1> nest_x{x, x};
   std::vector<T2> nest_y{y, y};
   std::vector<std::vector<T1>> nest_nest_x{nest_x, nest_x};
@@ -1368,10 +1366,8 @@ template <typename F, typename T1, typename T2,
           require_st_integral<T2>* = nullptr>
 void expect_ad_vectorized_binary_impl(const ad_tolerances& tols, const F& f,
                                       const T1& x, const T2& y) {
-  auto f_bind = [&](const auto& y) {
-    return
-        [=](const auto& x) { return f(x, y); };
-  };
+  auto f_bind
+      = [&](const auto& y) { return [=](const auto& x) { return f(x, y); }; };
   std::vector<T1> nest_x{x, x};
   std::vector<T2> nest_y{y, y};
   std::vector<std::vector<T1>> nest_nest_x{nest_x, nest_x};