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

Author: stan-buildbot

stan/math/prim/functor/integrate_1d.hpp

@@ -146,10 +146,10 @@ inline double integrate(const F& f, double a, double b,
  * @return numeric integral of function f
  */
 template <typename F, typename... Args,
-	  require_all_not_st_var<Args...>* = nullptr>
+          require_all_not_st_var<Args...>* = nullptr>
 inline double integrate_1d_impl(const F& f, double a, double b,
-				double relative_tolerance,
-				std::ostream* msgs, const Args&... args) {
+                                double relative_tolerance, std::ostream* msgs,
+                                const Args&... args) {
   static const char* function = "integrate_1d";
   check_less_or_equal(function, "lower limit", a, b);
 
@@ -159,10 +159,9 @@ inline double integrate_1d_impl(const F& f, double a, double b,
     }
     return 0.0;
   } else {
-    return integrate(
-        std::bind<double>(f, std::placeholders::_1, std::placeholders::_2,
-                          msgs, args...),
-        a, b, relative_tolerance);
+    return integrate(std::bind<double>(f, std::placeholders::_1,
+                                       std::placeholders::_2, msgs, args...),
+                     a, b, relative_tolerance);
   }
 }
 
@@ -219,9 +218,8 @@ inline double integrate_1d(const F& f, double a, double b,
                            const std::vector<int>& x_i, std::ostream* msgs,
                            const double relative_tolerance
                            = std::sqrt(EPSILON)) {
-  return integrate_1d_impl(integrate_1d_adapter<F>(f), a, b,
-			   relative_tolerance, msgs,
-			   theta, x_r, x_i);
+  return integrate_1d_impl(integrate_1d_adapter<F>(f), a, b, relative_tolerance,
+                           msgs, theta, x_r, x_i);
 }
 
 }  // namespace math

stan/math/prim/functor/integrate_1d_adapter.hpp

@@ -17,11 +17,10 @@ struct integrate_1d_adapter {
   explicit integrate_1d_adapter(const F& f) : f_(f) {}
 
   template <typename T_a, typename T_b, typename T_theta>
-  auto operator()(const T_a& x, const T_b& xc,
-		  std::ostream *msgs,
-		  const std::vector<T_theta> &theta,
-		  const std::vector<double> &x_r,
-		  const std::vector<int> &x_i) const {
+  auto operator()(const T_a& x, const T_b& xc, std::ostream* msgs,
+                  const std::vector<T_theta>& theta,
+                  const std::vector<double>& x_r,
+                  const std::vector<int>& x_i) const {
     return f_(x, xc, theta, x_r, x_i, msgs);
   }
 };

stan/math/rev/functor/integrate_1d.hpp

@@ -38,28 +38,30 @@ namespace math {
  */
 template <typename F, typename... Args>
 inline double gradient_of_f(const F &f, const double &x, const double &xc,
-			    size_t n, std::ostream *msgs, const Args&... args) {
+                            size_t n, std::ostream *msgs,
+                            const Args &... args) {
   double gradient = 0.0;
 
   // Run nested autodiff in this scope
   nested_rev_autodiff nested;
 
-  std::tuple<decltype(deep_copy_vars(args))...>
-    args_tuple_local_copy(deep_copy_vars(args)...);
+  std::tuple<decltype(deep_copy_vars(args))...> args_tuple_local_copy(
+      deep_copy_vars(args)...);
 
   Eigen::VectorXd adjoints = Eigen::VectorXd::Zero(count_vars(args...));
 
-  var fx = apply([&f, &x, &xc, msgs](auto&&... args) {
-    return f(x, xc, msgs, args...);
-  }, args_tuple_local_copy);
+  var fx = apply(
+      [&f, &x, &xc, msgs](auto &&... args) { return f(x, xc, msgs, args...); },
+      args_tuple_local_copy);
 
   fx.grad();
 
-  apply([&](auto&&... args) {
-    accumulate_adjoints(adjoints.data(),
-			std::forward<decltype(args)>(args)...);
-    },
-    std::move(args_tuple_local_copy));
+  apply(
+      [&](auto &&... args) {
+        accumulate_adjoints(adjoints.data(),
+                            std::forward<decltype(args)>(args)...);
+      },
+      std::move(args_tuple_local_copy));
 
   gradient = adjoints.coeff(n);
   if (is_nan(gradient)) {
@@ -90,13 +92,11 @@ inline double gradient_of_f(const F &f, const double &x, const double &xc,
  * @param args additional arguments to pass to f
  * @return numeric integral of function f
  */
-template <typename F, typename T_a, typename T_b,
-	  typename... Args,
-          require_any_st_var<T_a, T_b, Args...>* = nullptr>
+template <typename F, typename T_a, typename T_b, typename... Args,
+          require_any_st_var<T_a, T_b, Args...> * = nullptr>
 inline return_type_t<T_a, T_b, Args...> integrate_1d_impl(
-    const F &f, const T_a &a, const T_b &b,
-    double relative_tolerance,
-    std::ostream *msgs, const Args&... args) {
+    const F &f, const T_a &a, const T_b &b, double relative_tolerance,
+    std::ostream *msgs, const Args &... args) {
   static const char *function = "integrate_1d";
   check_less_or_equal(function, "lower limit", a, b);
 
@@ -105,65 +105,66 @@ inline return_type_t<T_a, T_b, Args...> integrate_1d_impl(
 
   if (a_val == b_val) {
     if (is_inf(a_val)) {
-      throw_domain_error(function, "Integration endpoints are both",
-                         a_val, "", "");
+      throw_domain_error(function, "Integration endpoints are both", a_val, "",
+                         "");
     }
     return var(0.0);
   } else {
-    std::tuple<decltype(value_of(args))...>
-      args_val_tuple(value_of(args)...);
+    std::tuple<decltype(value_of(args))...> args_val_tuple(value_of(args)...);
 
-    double integral = integrate(apply([&f, msgs](auto&&... args) {
-	return std::bind<double>(f, std::placeholders::_1, std::placeholders::_2,
-				 msgs, args...);
-	}, args_val_tuple),
-      a_val, b_val, relative_tolerance);
+    double integral = integrate(apply(
+                                    [&f, msgs](auto &&... args) {
+                                      return std::bind<double>(
+                                          f, std::placeholders::_1,
+                                          std::placeholders::_2, msgs, args...);
+                                    },
+                                    args_val_tuple),
+                                a_val, b_val, relative_tolerance);
 
     size_t num_vars_ab = count_vars(a, b);
     size_t num_vars_args = count_vars(args...);
-    vari** varis =
-      ChainableStack::instance_->memalloc_.alloc_array<vari*>(num_vars_ab +
-							      num_vars_args);
-    double* partials =
-      ChainableStack::instance_->memalloc_.alloc_array<double>(num_vars_ab +
-							       num_vars_args);
-    double* partials_ptr = partials;
+    vari **varis = ChainableStack::instance_->memalloc_.alloc_array<vari *>(
+        num_vars_ab + num_vars_args);
+    double *partials = ChainableStack::instance_->memalloc_.alloc_array<double>(
+        num_vars_ab + num_vars_args);
+    double *partials_ptr = partials;
 
     save_varis(varis, a, b, args...);
 
-    for(size_t i = 0; i < num_vars_ab + num_vars_args; ++i) {
+    for (size_t i = 0; i < num_vars_ab + num_vars_args; ++i) {
       partials[i] = 0.0;
     }
 
     if (!is_inf(a) && is_var<T_a>::value) {
-      *partials_ptr = apply([&f, a_val, msgs](auto&&... args) {
-        return -f(a_val, 0.0, msgs, args...);
-      }, args_val_tuple);
+      *partials_ptr = apply(
+          [&f, a_val, msgs](auto &&... args) {
+            return -f(a_val, 0.0, msgs, args...);
+          },
+          args_val_tuple);
       partials_ptr++;
     }
 
     if (!is_inf(b) && is_var<T_b>::value) {
-      *partials_ptr = apply([&f, b_val, msgs](auto&&... args) {
-	return f(b_val, 0.0, msgs, args...);
-      }, args_val_tuple);
+      *partials_ptr
+          = apply([&f, b_val, msgs](
+                      auto &&... args) { return f(b_val, 0.0, msgs, args...); },
+                  args_val_tuple);
       partials_ptr++;
     }
 
     for (size_t n = 0; n < num_vars_args; ++n) {
       *partials_ptr = integrate(
-        std::bind<double>(gradient_of_f<F, Args...>, f,
-			  std::placeholders::_1, std::placeholders::_2,
-			  n, msgs, args...),
-	a_val, b_val, relative_tolerance);
+          std::bind<double>(gradient_of_f<F, Args...>, f, std::placeholders::_1,
+                            std::placeholders::_2, n, msgs, args...),
+          a_val, b_val, relative_tolerance);
       partials_ptr++;
     }
 
-    return var(new precomputed_gradients_vari(integral,
-					      num_vars_ab + num_vars_args,
-					      varis, partials));
+    return var(new precomputed_gradients_vari(
+        integral, num_vars_ab + num_vars_args, varis, partials));
   }
 }
-  
+
 /**
  * Compute the integral of the single variable function f from a to b to within
  * a specified relative tolerance. a and b can be finite or infinite.
@@ -225,9 +226,8 @@ inline return_type_t<T_a, T_b, T_theta> integrate_1d(
     const F &f, const T_a &a, const T_b &b, const std::vector<T_theta> &theta,
     const std::vector<double> &x_r, const std::vector<int> &x_i,
     std::ostream *msgs, const double relative_tolerance = std::sqrt(EPSILON)) {
-  return integrate_1d_impl(integrate_1d_adapter<F>(f), a, b,
-			   relative_tolerance, msgs,
-			   theta, x_r, x_i);
+  return integrate_1d_impl(integrate_1d_adapter<F>(f), a, b, relative_tolerance,
+                           msgs, theta, x_r, x_i);
 }
 
 }  // namespace math