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

Author: stan-buildbot

stan/math/prim/prob/geometric_cdf.hpp

@@ -34,8 +34,7 @@ namespace math {
  * @throw std::invalid_argument if container sizes mismatch
  */
 template <typename T_n, typename T_prob>
-inline return_type_t<T_prob> geometric_cdf(const T_n& n,
-                                           const T_prob& theta) {
+inline return_type_t<T_prob> geometric_cdf(const T_n& n, const T_prob& theta) {
   using T_partials_return = partials_return_t<T_n, T_prob>;
   using T_n_ref = ref_type_t<T_n>;
   using T_prob_ref = ref_type_t<T_prob>;
@@ -49,8 +48,8 @@ inline return_type_t<T_prob> geometric_cdf(const T_n& n,
 
   T_n_ref n_ref = n;
   T_prob_ref theta_ref = theta;
-  check_bounded(function, "Success probability parameter",
-                value_of(theta_ref), 0.0, 1.0);
+  check_bounded(function, "Success probability parameter", value_of(theta_ref),
+                0.0, 1.0);
 
   scalar_seq_view<T_n_ref> n_vec(n_ref);
   scalar_seq_view<T_prob_ref> theta_vec(theta_ref);

stan/math/prim/prob/geometric_lccdf.hpp

@@ -47,8 +47,8 @@ inline return_type_t<T_prob> geometric_lccdf(const T_n& n,
 
   T_n_ref n_ref = n;
   T_prob_ref theta_ref = theta;
-  check_bounded(function, "Success probability parameter",
-                value_of(theta_ref), 0.0, 1.0);
+  check_bounded(function, "Success probability parameter", value_of(theta_ref),
+                0.0, 1.0);
 
   scalar_seq_view<T_n_ref> n_vec(n_ref);
   scalar_seq_view<T_prob_ref> theta_vec(theta_ref);

stan/math/prim/prob/geometric_lcdf.hpp

@@ -34,8 +34,7 @@ namespace math {
  * @throw std::invalid_argument if container sizes mismatch
  */
 template <typename T_n, typename T_prob>
-inline return_type_t<T_prob> geometric_lcdf(const T_n& n,
-                                            const T_prob& theta) {
+inline return_type_t<T_prob> geometric_lcdf(const T_n& n, const T_prob& theta) {
   using T_partials_return = partials_return_t<T_n, T_prob>;
   using T_n_ref = ref_type_t<T_n>;
   using T_prob_ref = ref_type_t<T_prob>;
@@ -49,8 +48,8 @@ inline return_type_t<T_prob> geometric_lcdf(const T_n& n,
 
   T_n_ref n_ref = n;
   T_prob_ref theta_ref = theta;
-  check_bounded(function, "Success probability parameter",
-                value_of(theta_ref), 0.0, 1.0);
+  check_bounded(function, "Success probability parameter", value_of(theta_ref),
+                0.0, 1.0);
 
   scalar_seq_view<T_n_ref> n_vec(n_ref);
   scalar_seq_view<T_prob_ref> theta_vec(theta_ref);

stan/math/prim/prob/geometric_lpmf.hpp

@@ -44,8 +44,7 @@ namespace math {
 template <bool propto, typename T_n, typename T_prob,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               T_n, T_prob>* = nullptr>
-inline return_type_t<T_prob> geometric_lpmf(const T_n& n,
-                                            const T_prob& theta) {
+inline return_type_t<T_prob> geometric_lpmf(const T_n& n, const T_prob& theta) {
   using std::log;
   using T_partials_return = partials_return_t<T_n, T_prob>;
   using T_n_ref = ref_type_t<T_n>;
@@ -60,8 +59,8 @@ inline return_type_t<T_prob> geometric_lpmf(const T_n& n,
   T_n_ref n_ref = n;
   T_prob_ref theta_ref = theta;
   check_nonnegative(function, "Outcome variable", n_ref);
-  check_bounded(function, "Success probability parameter",
-                value_of(theta_ref), 0.0, 1.0);
+  check_bounded(function, "Success probability parameter", value_of(theta_ref),
+                0.0, 1.0);
 
   if constexpr (!include_summand<propto, T_prob>::value) {
     return 0.0;
@@ -103,8 +102,7 @@ inline return_type_t<T_prob> geometric_lpmf(const T_n& n,
 }
 
 template <typename T_n, typename T_prob>
-inline return_type_t<T_prob> geometric_lpmf(const T_n& n,
-                                            const T_prob& theta) {
+inline return_type_t<T_prob> geometric_lpmf(const T_n& n, const T_prob& theta) {
   return geometric_lpmf<false>(n, theta);
 }
 

stan/math/prim/prob/geometric_rng.hpp

@@ -63,8 +63,8 @@ inline auto geometric_rng(T_prob&& theta, RNG& rng) {
         result[i] = 0;
       } else {
         double u_i = uniform(rng);
-        result[i] = static_cast<int>(
-            std::floor(std::log(u_i) / log1m(theta_arr[i])));
+        result[i]
+            = static_cast<int>(std::floor(std::log(u_i) / log1m(theta_arr[i])));
       }
     }
     return result;

test/prob/geometric/geometric_cdf_test.hpp

@@ -59,9 +59,9 @@ class AgradCdfGeometric : public AgradCdfTest {
   template <class T_n, class T_prob, typename T2, typename T3, typename T4,
             typename T5>
   stan::return_type_t<T_n, T_prob> cdf_function(const T_n& n,
-                                                const T_prob& theta,
-                                                const T2&, const T3&,
-                                                const T4&, const T5&) {
+                                                const T_prob& theta, const T2&,
+                                                const T3&, const T4&,
+                                                const T5&) {
     using stan::math::log1m;
     return 1.0 - stan::math::exp((n + 1.0) * log1m(theta));
   }

test/unit/math/prim/prob/geometric_test.cpp

@@ -11,8 +11,8 @@ class GeometricTestRig : public VectorIntRNGTestRig {
  public:
   GeometricTestRig()
       : VectorIntRNGTestRig(10000, 10, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
-                            {0.1, 0.3, 0.5, 0.7, 0.9}, {1},
-                            {-0.1, 1.1}, {-1, 0, 2}) {}
+                            {0.1, 0.3, 0.5, 0.7, 0.9}, {1}, {-0.1, 1.1},
+                            {-1, 0, 2}) {}
 
   template <typename T1, typename T2, typename T3, typename T_rng>
   auto generate_samples(const T1& theta, const T2&, const T3&,