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

Author: stan-buildbot

stan/math/prim/constraint/lub_constrain.hpp

@@ -121,9 +121,12 @@ template <typename T, typename L, typename U, require_eigen_t<T>* = nullptr,
           require_all_stan_scalar_t<L, U>* = nullptr,
           require_not_var_t<return_type_t<T, L, U>>* = nullptr>
 inline auto lub_constrain(T&& x, const L& lb, const U& ub) {
-  return make_holder([lb, ub](auto&& x_) {
-    return std::forward<decltype(x_)>(x_).unaryExpr([lb, ub](auto&& xx) { return lub_constrain(xx, lb, ub); });
-  }, std::forward<T>(x));
+  return make_holder(
+      [lb, ub](auto&& x_) {
+        return std::forward<decltype(x_)>(x_).unaryExpr(
+            [lb, ub](auto&& xx) { return lub_constrain(xx, lb, ub); });
+      },
+      std::forward<T>(x));
 }
 
 /**
@@ -135,10 +138,12 @@ template <typename T, typename L, typename U, typename Lp,
           require_not_var_t<return_type_t<T, L, U>>* = nullptr,
           require_convertible_t<return_type_t<T, L, U>, Lp>* = nullptr>
 inline auto lub_constrain(T&& x, const L& lb, const U& ub, Lp& lp) {
-  return eval(make_holder([lb, ub, &lp](auto&& x_) {
-    return std::forward<decltype(x_)>(x_).unaryExpr(
-      [lb, ub, &lp](auto&& xx) { return lub_constrain(xx, lb, ub, lp); });
-  }, std::forward<T>(x)));
+  return eval(make_holder(
+      [lb, ub, &lp](auto&& x_) {
+        return std::forward<decltype(x_)>(x_).unaryExpr(
+            [lb, ub, &lp](auto&& xx) { return lub_constrain(xx, lb, ub, lp); });
+      },
+      std::forward<T>(x)));
 }
 
 /**
@@ -151,11 +156,13 @@ template <typename T, typename L, typename U,
           require_not_var_t<return_type_t<T, L, U>>* = nullptr>
 inline auto lub_constrain(T&& x, L&& lb, const U& ub) {
   check_matching_dims("lub_constrain", "x", x, "lb", lb);
-  return make_holder([ub](auto&& x_, auto&& lb_) {
-    return std::forward<decltype(x_)>(x_).binaryExpr(lb_, [ub](auto&& xx, auto&& llb) {
-      return lub_constrain(xx, llb, ub);
-    });
-  }, std::forward<T>(x), std::forward<L>(lb));
+  return make_holder(
+      [ub](auto&& x_, auto&& lb_) {
+        return std::forward<decltype(x_)>(x_).binaryExpr(
+            lb_,
+            [ub](auto&& xx, auto&& llb) { return lub_constrain(xx, llb, ub); });
+      },
+      std::forward<T>(x), std::forward<L>(lb));
 }
 
 /**
@@ -169,11 +176,13 @@ template <typename T, typename L, typename U, typename Lp,
           require_convertible_t<return_type_t<T, L, U>, Lp>* = nullptr>
 inline auto lub_constrain(T&& x, L&& lb, const U& ub, Lp& lp) {
   check_matching_dims("lub_constrain", "x", x, "lb", lb);
-  return eval(make_holder([ub, &lp](auto&& x_, auto&& lb_) {
-    return to_ref(x_).binaryExpr(lb_, [ub, &lp](auto&& xx, auto&& llb) {
-      return lub_constrain(xx, llb, ub, lp);
-    });
-  }, std::forward<T>(x), std::forward<L>(lb)));
+  return eval(make_holder(
+      [ub, &lp](auto&& x_, auto&& lb_) {
+        return to_ref(x_).binaryExpr(lb_, [ub, &lp](auto&& xx, auto&& llb) {
+          return lub_constrain(xx, llb, ub, lp);
+        });
+      },
+      std::forward<T>(x), std::forward<L>(lb)));
 }
 
 /**
@@ -186,11 +195,13 @@ template <typename T, typename L, typename U,
           require_not_var_t<return_type_t<T, L, U>>* = nullptr>
 inline auto lub_constrain(T&& x, const L& lb, U&& ub) {
   check_matching_dims("lub_constrain", "x", x, "ub", ub);
-  return make_holder([lb](auto&& x_, auto&& ub_){
-    return x_.binaryExpr(ub_, [lb](auto&& xx, auto&& uub) {
-      return lub_constrain(xx, lb, uub);
-    });
-  }, std::forward<T>(x), std::forward<U>(ub));
+  return make_holder(
+      [lb](auto&& x_, auto&& ub_) {
+        return x_.binaryExpr(ub_, [lb](auto&& xx, auto&& uub) {
+          return lub_constrain(xx, lb, uub);
+        });
+      },
+      std::forward<T>(x), std::forward<U>(ub));
 }
 
 /**
@@ -204,11 +215,13 @@ template <typename T, typename L, typename U, typename Lp,
           require_convertible_t<return_type_t<T, L, U>, Lp>* = nullptr>
 inline auto lub_constrain(T&& x, const L& lb, U&& ub, Lp& lp) {
   check_matching_dims("lub_constrain", "x", x, "ub", ub);
-  return eval(make_holder([lb, &lp](auto&& x_, auto&& ub_){
-    return x_.binaryExpr(ub_, [lb, &lp](auto&& xx, auto&& uub) {
-      return lub_constrain(xx, lb, uub, lp);
-    });
-  }, std::forward<T>(x), std::forward<U>(ub)));
+  return eval(make_holder(
+      [lb, &lp](auto&& x_, auto&& ub_) {
+        return x_.binaryExpr(ub_, [lb, &lp](auto&& xx, auto&& uub) {
+          return lub_constrain(xx, lb, uub, lp);
+        });
+      },
+      std::forward<T>(x), std::forward<U>(ub)));
 }
 
 /**

test/unit/math/mix/constraint/lub_constrain_helpers.hpp

@@ -6,29 +6,45 @@ template <typename T1, typename T2, typename T3>
 inline void expect(const T1& x, const T2& lb, const T3& ub) {
   auto f1 = [](auto&& x, auto&& lb, auto&& ub) {
     stan::return_type_t<decltype(x), decltype(lb), decltype(ub)> lp = 0;
-    return stan::math::lub_constrain<false>(std::forward<decltype(x)>(x), std::forward<decltype(lb)>(lb), std::forward<decltype(ub)>(ub), lp);
+    return stan::math::lub_constrain<false>(std::forward<decltype(x)>(x),
+                                            std::forward<decltype(lb)>(lb),
+                                            std::forward<decltype(ub)>(ub), lp);
   };
   auto f2 = [](auto&& x, auto&& lb, auto&& ub) {
     stan::return_type_t<decltype(x), decltype(lb), decltype(ub)> lp = 0;
-    return stan::math::lub_constrain<true>(std::forward<decltype(x)>(x), std::forward<decltype(lb)>(lb), std::forward<decltype(ub)>(ub), lp);
+    return stan::math::lub_constrain<true>(std::forward<decltype(x)>(x),
+                                           std::forward<decltype(lb)>(lb),
+                                           std::forward<decltype(ub)>(ub), lp);
   };
   auto f3 = [](auto&& x, auto&& lb, auto&& ub) {
     stan::return_type_t<decltype(x), decltype(lb), decltype(ub)> lp = 0;
-    stan::math::lub_constrain<true>(std::forward<decltype(x)>(x), std::forward<decltype(lb)>(lb), std::forward<decltype(ub)>(ub), lp);
+    stan::math::lub_constrain<true>(std::forward<decltype(x)>(x),
+                                    std::forward<decltype(lb)>(lb),
+                                    std::forward<decltype(ub)>(ub), lp);
     return lp;
   };
   auto f4 = [](auto&& x, auto&& lb, auto&& ub) {
     stan::return_type_t<decltype(x), decltype(lb), decltype(ub)> lp = 0;
-    auto xx = stan::math::lub_constrain<true>(std::forward<decltype(x)>(x), std::forward<decltype(lb)>(lb), std::forward<decltype(ub)>(ub), lp);
+    auto xx = stan::math::lub_constrain<true>(
+        std::forward<decltype(x)>(x), std::forward<decltype(lb)>(lb),
+        std::forward<decltype(ub)>(ub), lp);
     return stan::math::add(lp, stan::math::sum(std::move(xx)));
   };
   auto f5 = [](auto&& x, auto&& lb, auto&& ub) {
     stan::return_type_t<decltype(x), decltype(lb), decltype(ub)> lp = 0;
-    return stan::math::lub_constrain<false>(std::forward<decltype(x)>(x), std::forward_as_tuple(std::forward<decltype(lb)>(lb), std::forward<decltype(ub)>(ub)), lp);
+    return stan::math::lub_constrain<false>(
+        std::forward<decltype(x)>(x),
+        std::forward_as_tuple(std::forward<decltype(lb)>(lb),
+                              std::forward<decltype(ub)>(ub)),
+        lp);
   };
   auto f6 = [](auto&& x, auto&& lb, auto&& ub) {
     stan::return_type_t<decltype(x), decltype(lb), decltype(ub)> lp = 0;
-    return stan::math::lub_constrain<true>(std::forward<decltype(x)>(x), std::forward_as_tuple(std::forward<decltype(lb)>(lb), std::forward<decltype(ub)>(ub)), lp);
+    return stan::math::lub_constrain<true>(
+        std::forward<decltype(x)>(x),
+        std::forward_as_tuple(std::forward<decltype(lb)>(lb),
+                              std::forward<decltype(ub)>(ub)),
+        lp);
   };
 
   stan::test::expect_ad(f1, x, lb, ub);
@@ -42,20 +58,28 @@ template <typename T1, typename T2, typename T3>
 inline void expect_vec(const T1& x, const T2& lb, const T3& ub) {
   auto f1 = [](auto&& x, auto&& lb, auto&& ub) {
     stan::return_type_t<decltype(x), decltype(lb), decltype(ub)> lp = 0;
-    return stan::math::lub_constrain<false>(std::forward<decltype(x)>(x), std::forward<decltype(lb)>(lb), std::forward<decltype(ub)>(ub), lp);
+    return stan::math::lub_constrain<false>(std::forward<decltype(x)>(x),
+                                            std::forward<decltype(lb)>(lb),
+                                            std::forward<decltype(ub)>(ub), lp);
   };
   auto f2 = [](auto&& x, auto&& lb, auto&& ub) {
     stan::return_type_t<decltype(x), decltype(lb), decltype(ub)> lp = 0;
-    return stan::math::lub_constrain<true>(std::forward<decltype(x)>(x), std::forward<decltype(lb)>(lb), std::forward<decltype(ub)>(ub), lp);
+    return stan::math::lub_constrain<true>(std::forward<decltype(x)>(x),
+                                           std::forward<decltype(lb)>(lb),
+                                           std::forward<decltype(ub)>(ub), lp);
   };
   auto f3 = [](auto&& x, auto&& lb, auto&& ub) {
     stan::return_type_t<decltype(x), decltype(lb), decltype(ub)> lp = 0;
-    stan::math::lub_constrain<true>(std::forward<decltype(x)>(x), std::forward<decltype(lb)>(lb), std::forward<decltype(ub)>(ub), lp);
+    stan::math::lub_constrain<true>(std::forward<decltype(x)>(x),
+                                    std::forward<decltype(lb)>(lb),
+                                    std::forward<decltype(ub)>(ub), lp);
     return lp;
   };
   auto f4 = [](auto&& x, auto&& lb, auto&& ub) {
     stan::return_type_t<decltype(x), decltype(lb), decltype(ub)> lp = 0;
-    auto xx = stan::math::eval(stan::math::lub_constrain<true>(std::forward<decltype(x)>(x), std::forward<decltype(lb)>(lb), std::forward<decltype(ub)>(ub), lp));
+    auto xx = stan::math::eval(stan::math::lub_constrain<true>(
+        std::forward<decltype(x)>(x), std::forward<decltype(lb)>(lb),
+        std::forward<decltype(ub)>(ub), lp));
     stan::return_type_t<decltype(x), decltype(lb), decltype(ub)> xx_acc = 0;
     for (size_t i = 0; i < xx.size(); ++i) {
       xx_acc += stan::math::sum(xx[i]);
@@ -64,11 +88,19 @@ inline void expect_vec(const T1& x, const T2& lb, const T3& ub) {
   };
   auto f5 = [](auto&& x, auto&& lb, auto&& ub) {
     stan::return_type_t<decltype(x), decltype(lb), decltype(ub)> lp = 0;
-    return stan::math::lub_constrain<false>(std::forward<decltype(x)>(x), std::make_tuple(std::forward<decltype(lb)>(lb), std::forward<decltype(ub)>(ub)), lp);
+    return stan::math::lub_constrain<false>(
+        std::forward<decltype(x)>(x),
+        std::make_tuple(std::forward<decltype(lb)>(lb),
+                        std::forward<decltype(ub)>(ub)),
+        lp);
   };
   auto f6 = [](auto&& x, auto&& lb, auto&& ub) {
     stan::return_type_t<decltype(x), decltype(lb), decltype(ub)> lp = 0;
-    return stan::math::lub_constrain<true>(std::forward<decltype(x)>(x), std::make_tuple(std::forward<decltype(lb)>(lb), std::forward<decltype(ub)>(ub)), lp);
+    return stan::math::lub_constrain<true>(
+        std::forward<decltype(x)>(x),
+        std::make_tuple(std::forward<decltype(lb)>(lb),
+                        std::forward<decltype(ub)>(ub)),
+        lp);
   };
 
   stan::test::expect_ad(f1, x, lb, ub);

test/unit/math/test_ad.hpp

@@ -1031,7 +1031,6 @@ inline std::vector<double> common_args(F&& comparison) {
   return common_args_filtered;
 }
 
-
 inline std::vector<int> common_nonzero_int_args() {
   static const std::vector<int> args{-1, 1};
   return args;