[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/ode_rk45.hpp

@@ -164,7 +164,7 @@ ode_rk45_tol(const F& f,
   size_t time_index = 0;
 
   max_step_checker step_checker(max_num_steps);
-  
+
   // avoid recording of the initial state which is included by the
   // conventions of odeint in the output
   auto filtered_observer
@@ -173,9 +173,8 @@ ode_rk45_tol(const F& f,
       observer_initial_recorded = true;
       return;
     }
-    y.emplace_back(ode_store_sensitivities(f, coupled_state, y0,
-					   t0, ts[time_index],
-					   msgs, args...));
+    y.emplace_back(ode_store_sensitivities(f, coupled_state, y0, t0,
+                                           ts[time_index], msgs, args...));
     step_checker.reset();
     time_index++;
   };
@@ -185,13 +184,12 @@ ode_rk45_tol(const F& f,
 
   const double step_size = 0.1;
   integrate_times(
-      make_dense_output(absolute_tolerance, relative_tolerance,
-                        runge_kutta_dopri5<Eigen::VectorXd, double,
-			                   Eigen::VectorXd, double,
-			                   vector_space_algebra>()),
-      std::ref(coupled_system), initial_coupled_state,
-      std::begin(ts_vec), std::end(ts_vec), step_size, filtered_observer,
-      step_checker);
+      make_dense_output(
+          absolute_tolerance, relative_tolerance,
+          runge_kutta_dopri5<Eigen::VectorXd, double, Eigen::VectorXd, double,
+                             vector_space_algebra>()),
+      std::ref(coupled_system), initial_coupled_state, std::begin(ts_vec),
+      std::end(ts_vec), step_size, filtered_observer, step_checker);
 
   return y;
 }

stan/math/prim/functor/ode_store_sensitivities.hpp

@@ -11,7 +11,7 @@ namespace math {
 /**
  * Build output for state of ODE solve from the current coupled_state when
  * all arguments are arithmetic.
- * 
+ *
  * @tparam F Type of ODE right hand side
  *
  * @param f Right hand side of the ODE
@@ -26,12 +26,10 @@ namespace math {
 template <typename F, typename... Args,
           typename = require_all_arithmetic_t<scalar_type_t<Args>...>>
 Eigen::VectorXd ode_store_sensitivities(const F& f,
-					const Eigen::VectorXd& coupled_state,
-					const Eigen::VectorXd& y0,
-					double t0,
-					double t,
-					std::ostream* msgs,
-					const Args&... args) {
+                                        const Eigen::VectorXd& coupled_state,
+                                        const Eigen::VectorXd& y0, double t0,
+                                        double t, std::ostream* msgs,
+                                        const Args&... args) {
   return coupled_state.head(y0.size());
 }
 

stan/math/rev/functor/cvodes_integrator.hpp

@@ -27,7 +27,8 @@ namespace math {
  * @tparam T_t0 Type of scalar of initial time point
  * @tparam T_ts Type of time-points where ODE solution is returned
  */
-template <int Lmm, typename F, typename T_y0, typename T_t0, typename T_ts, typename... T_Args>
+template <int Lmm, typename F, typename T_y0, typename T_t0, typename T_ts,
+          typename... T_Args>
 class cvodes_integrator {
   using T_Return = return_type_t<T_y0, T_t0, T_ts, T_Args...>;
   using T_y0_t0 = return_type_t<T_y0, T_t0>;
@@ -169,19 +170,20 @@ class cvodes_integrator {
    * @param max_num_steps Upper limit on the number of integration steps to
    *   take between each output (error if exceeded)
    * @param[in, out] msgs the print stream for warning messages
-   * @param args Extra arguments passed unmodified through to ODE right hand side
-   *   function
+   * @param args Extra arguments passed unmodified through to ODE right hand
+   * side function
    * @return Solution to ODE at times \p ts
    * @return a vector of states, each state being a vector of the
    * same size as the state variable, corresponding to a time in ts.
    */
-  cvodes_integrator(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
-		    const T_t0& t0, const std::vector<T_ts>& ts,
-		    double relative_tolerance, double absolute_tolerance,
-		    long int max_num_steps,
-                    std::ostream* msgs, const T_Args&... args)
+  cvodes_integrator(const F& f,
+                    const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
+                    const T_t0& t0, const std::vector<T_ts>& ts,
+                    double relative_tolerance, double absolute_tolerance,
+                    long int max_num_steps, std::ostream* msgs,
+                    const T_Args&... args)
       : f_(f),
-	y0_(y0.unaryExpr([](const T_y0& val) { return T_y0_t0(val); })),
+        y0_(y0.unaryExpr([](const T_y0& val) { return T_y0_t0(val); })),
         t0_(t0),
         ts_(ts),
         args_tuple_(args...),

stan/math/rev/functor/ode_store_sensitivities.hpp

@@ -30,14 +30,12 @@ namespace math {
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return ODE state with scalar type var
  */
-template <typename F, typename T_y0_t0, typename T_t0, typename T_t, typename... Args>
-Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(const F& f,
-							      const Eigen::VectorXd& coupled_state,
-							      const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0,
-							      const T_t0& t0,
-							      const T_t& t,
-							      std::ostream* msgs,
-							      const Args&... args) {
+template <typename F, typename T_y0_t0, typename T_t0, typename T_t,
+          typename... Args>
+Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
+    const F& f, const Eigen::VectorXd& coupled_state,
+    const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0, const T_t0& t0,
+    const T_t& t, std::ostream* msgs, const Args&... args) {
   const size_t N = y0.size();
   const size_t y0_vars = count_vars(y0);
   const size_t args_vars = count_vars(args...);