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

Author: stan-buildbot

stan/math/prim/meta/compiler_attributes.hpp

@@ -30,7 +30,6 @@
 
 #endif
 
-
 #ifndef STAN_COLD_PATH
 #define STAN_COLD_PATH
 #endif

test/unit/math/rev/functor/lorenz_ode_typed_fd_test.cpp

@@ -22,13 +22,14 @@ using lorenz_test_types = boost::mp11::mp_product<
 
 TYPED_TEST_SUITE_P(lorenz_test);
 TYPED_TEST_P(lorenz_test, param_and_data_finite_diff) {
-  if constexpr (std::is_same<TypeParam,
-                   std::tuple<ode_rk45_functor, ode_rk45_functor>>::value) {
+  if constexpr (std::is_same<TypeParam, std::tuple<ode_rk45_functor,
+                                                   ode_rk45_functor>>::value) {
     this->test_fd_vd(1.e-6, 3e-2);
     this->test_fd_dv(1.e-6, 3e-2);
     this->test_fd_vv(1.e-6, 3e-2);
-  } else if constexpr (std::is_same<TypeParam, std::tuple<ode_ckrk_functor,
-                                                ode_ckrk_functor>>::value) {
+  } else if constexpr (std::is_same<TypeParam,
+                                    std::tuple<ode_ckrk_functor,
+                                               ode_ckrk_functor>>::value) {
     this->test_fd_vd(1.e-6, 5e-2);
     this->test_fd_dv(1.e-6, 5e-2);
     this->test_fd_vv(1.e-6, 5e-2);

test/unit/math/rev/functor/sho_ode_adjoint_typed_error_test.cpp

@@ -36,8 +36,10 @@ TYPED_TEST_P(harmonic_oscillator_ctl_test, value) {
   this->test_value(-1.0);
 
   if constexpr (std::is_same<std::tuple_element_t<2, TypeParam>, double>::value
-      && std::is_same<std::tuple_element_t<3, TypeParam>, double>::value
-      && std::is_same<std::tuple_element_t<4, TypeParam>, double>::value) {
+                && std::is_same<std::tuple_element_t<3, TypeParam>,
+                                double>::value
+                && std::is_same<std::tuple_element_t<4, TypeParam>,
+                                double>::value) {
     EXPECT_EQ(stan::math::nested_size(), 0);
   } else {
     EXPECT_GT(stan::math::nested_size(), 0);

test/unit/math/rev/functor/sho_ode_typed_test.cpp

@@ -101,23 +101,23 @@ using harmonic_oscillator_test_types = boost::mp11::mp_product<
 TYPED_TEST_SUITE_P(harmonic_oscillator_t0_ad_test);
 TYPED_TEST_P(harmonic_oscillator_t0_ad_test, t0_ad) {
   if constexpr (std::is_same<std::tuple_element_t<0, TypeParam>,
-                   ode_rk45_functor>::value) {
+                             ode_rk45_functor>::value) {
     this->test_t0_ad(5e-6);
   }
   if constexpr (std::is_same<std::tuple_element_t<0, TypeParam>,
-                   ode_ckrk_functor>::value) {
+                             ode_ckrk_functor>::value) {
     this->test_t0_ad(5e-6);
   }
   if constexpr (std::is_same<std::tuple_element_t<0, TypeParam>,
-                   ode_adams_functor>::value) {
+                             ode_adams_functor>::value) {
     this->test_t0_ad(1e-8);
   }
   if constexpr (std::is_same<std::tuple_element_t<0, TypeParam>,
-                   ode_bdf_functor>::value) {
+                             ode_bdf_functor>::value) {
     this->test_t0_ad(1e-7);
   }
   if constexpr (std::is_same<std::tuple_element_t<0, TypeParam>,
-                   ode_adjoint_functor>::value) {
+                             ode_adjoint_functor>::value) {
     this->test_t0_ad(1e-7);
   }
 }

test/unit/math/test_ad_matvar.hpp

@@ -431,7 +431,7 @@ void expect_ad_matvar_impl(const ad_tolerances& tols, const F& f,
     FAIL() << "expect_ad_matvar requires at least one varmat input!"
            << std::endl;
   } else if constexpr (!stan::math::disjunction<
-                    is_var<scalar_type_t<Types>>...>::value) {
+                           is_var<scalar_type_t<Types>>...>::value) {
     FAIL() << "expect_ad_matvar requires at least one autodiff input!"
            << std::endl;
   } else {
@@ -459,15 +459,15 @@ void expect_ad_matvar_impl(const ad_tolerances& tols, const F& f,
       T_vm_ret A_vm_ret;
 
       if constexpr (is_var_matrix<T_mv_ret>::value
-          || (is_std_vector<T_mv_ret>::value
-              && is_var_matrix<value_type_t<T_mv_ret>>::value)) {
+                    || (is_std_vector<T_mv_ret>::value
+                        && is_var_matrix<value_type_t<T_mv_ret>>::value)) {
         FAIL() << "A function with matvar inputs should not return "
                << type_name<T_mv_ret>() << std::endl;
       }
 
       if constexpr (is_eigen<T_vm_ret>::value
-          || (is_std_vector<T_vm_ret>::value
-              && is_eigen<value_type_t<T_vm_ret>>::value)) {
+                    || (is_std_vector<T_vm_ret>::value
+                        && is_eigen<value_type_t<T_vm_ret>>::value)) {
         FAIL() << "A function with varmat inputs should not return "
                << type_name<T_vm_ret>() << std::endl;
       }