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

Author: stan-buildbot

stan/math/fwd/fun/log_sum_exp.hpp

@@ -52,15 +52,17 @@ inline fvar<T> log_sum_exp(const fvar<T>& x1, double x2) {
  */
 template <typename T, require_container_st<is_fvar, T>* = nullptr>
 inline auto log_sum_exp(const T& x) {
-  return apply_vector_unary<ref_type_t<T>>::reduce(to_ref(x), [&](const auto& v) {
-    using T_fvar_inner = typename value_type_t<decltype(v)>::Scalar;
-    using mat_type = Eigen::Matrix<T_fvar_inner, -1, -1>;
-    mat_type vals = v.val();
-    mat_type exp_vals = vals.array().exp();
+  return apply_vector_unary<ref_type_t<T>>::reduce(
+      to_ref(x), [&](const auto& v) {
+        using T_fvar_inner = typename value_type_t<decltype(v)>::Scalar;
+        using mat_type = Eigen::Matrix<T_fvar_inner, -1, -1>;
+        mat_type vals = v.val();
+        mat_type exp_vals = vals.array().exp();
 
-    return fvar<T_fvar_inner>(
-        log_sum_exp(vals), v.d().cwiseProduct(exp_vals).sum() / exp_vals.sum());
-  });
+        return fvar<T_fvar_inner>(
+            log_sum_exp(vals),
+            v.d().cwiseProduct(exp_vals).sum() / exp_vals.sum());
+      });
 }
 
 }  // namespace math

stan/math/fwd/fun/quad_form_sym.hpp

@@ -33,7 +33,8 @@ inline promote_scalar_t<return_type_t<EigMat1, EigMat2>, EigMat2> quad_form_sym(
   check_multiplicable("quad_form_sym", "A", A, "B", B);
   check_symmetric("quad_form_sym", "A", A);
   const auto& B_ref = to_ref(B);
-  promote_scalar_t<T_ret, EigMat2> ret(multiply(B_ref.transpose(), multiply(A, B_ref)));
+  promote_scalar_t<T_ret, EigMat2> ret(
+      multiply(B_ref.transpose(), multiply(A, B_ref)));
   return T_ret(0.5) * (ret + ret.transpose());
 }
 

stan/math/prim/err/check_symmetric.hpp

@@ -28,9 +28,8 @@ namespace math {
  *   main diagonal is <code>NaN</code>
  */
 template <typename EigMat, require_eigen_t<EigMat>* = nullptr>
-inline void check_symmetric(
-    const char* function, const char* name,
-    const EigMat& y) {
+inline void check_symmetric(const char* function, const char* name,
+                            const EigMat& y) {
   check_square(function, name, y);
   using std::fabs;
 

stan/math/prim/fun/log_mix.hpp

@@ -88,12 +88,15 @@ return_type_t<T_theta, T_lam> log_mix(const T_theta& theta,
   check_bounded(function, "theta", theta_ref, 0, 1);
   check_finite(function, "lambda", lambda_ref);
 
-  const auto& theta_dbl = to_ref(value_of(as_column_vector_or_scalar(theta_ref)));
-  const auto& lam_dbl = to_ref(value_of(as_column_vector_or_scalar(lambda_ref)));
+  const auto& theta_dbl
+      = to_ref(value_of(as_column_vector_or_scalar(theta_ref)));
+  const auto& lam_dbl
+      = to_ref(value_of(as_column_vector_or_scalar(lambda_ref)));
 
   T_partials_return logp = log_sum_exp(log(theta_dbl) + lam_dbl);
 
-  operands_and_partials<T_theta_ref, T_lam_ref> ops_partials(theta_ref, lambda_ref);
+  operands_and_partials<T_theta_ref, T_lam_ref> ops_partials(theta_ref,
+                                                             lambda_ref);
   if (!is_constant_all<T_lam, T_theta>::value) {
     T_partials_vec theta_deriv = (lam_dbl.array() - logp).exp();
     if (!is_constant_all<T_lam>::value) {
@@ -160,7 +163,8 @@ return_type_t<T_theta, std::vector<T_lam>> log_mix(
     check_consistent_sizes(function, "theta", theta, "lambda", lambda[n]);
   }
 
-  const auto& theta_dbl = to_ref(value_of(as_column_vector_or_scalar(theta_ref)));
+  const auto& theta_dbl
+      = to_ref(value_of(as_column_vector_or_scalar(theta_ref)));
 
   T_partials_mat lam_dbl(M, N);
   for (int n = 0; n < N; ++n) {
@@ -173,7 +177,8 @@ return_type_t<T_theta, std::vector<T_lam>> log_mix(
     logp[n] = log_sum_exp(logp_tmp.col(n));
   }
 
-  operands_and_partials<T_theta_ref, T_lamvec_type> ops_partials(theta_ref, lambda);
+  operands_and_partials<T_theta_ref, T_lamvec_type> ops_partials(theta_ref,
+                                                                 lambda);
   if (!is_constant_all<T_theta, T_lam>::value) {
     T_partials_mat derivs = exp(lam_dbl.rowwise() - logp.transpose());
     if (!is_constant_all<T_theta>::value) {

stan/math/prim/fun/mdivide_left_spd.hpp

@@ -39,7 +39,8 @@ mdivide_left_spd(const EigMat1& A, const EigMat2& b) {
 
   auto llt
       = Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
-                      EigMat1::RowsAtCompileTime, EigMat1::ColsAtCompileTime>(A_ref)
+                      EigMat1::RowsAtCompileTime, EigMat1::ColsAtCompileTime>(
+            A_ref)
             .llt();
   check_pos_definite(function, "A", llt);
   return llt.solve(

stan/math/prim/fun/mdivide_right_tri.hpp

@@ -95,7 +95,8 @@ mdivide_right_tri(const EigMat1& b, const EigMat2& A) {
     return from_matrix_cl(C_cl);
   } else {
 #endif
-    return to_ref(A).template triangularView<TriView>()
+    return to_ref(A)
+        .template triangularView<TriView>()
         .transpose()
         .solve(b.transpose())
         .transpose();

stan/math/prim/fun/trace_gen_quad_form.hpp

@@ -38,7 +38,7 @@ inline auto trace_gen_quad_form(const TD &D, const TA &A, const TB &B) {
   check_square("trace_gen_quad_form", "D", D);
   check_multiplicable("trace_gen_quad_form", "A", A, "B", B);
   check_multiplicable("trace_gen_quad_form", "B", B, "D", D);
-  const auto& B_ref = to_ref(B);
+  const auto &B_ref = to_ref(B);
   return multiply(B_ref, D.transpose()).cwiseProduct(multiply(A, B_ref)).sum();
 }
 
@@ -67,7 +67,7 @@ inline double trace_gen_quad_form(const TD &D, const TA &A, const TB &B) {
   check_square("trace_gen_quad_form", "D", D);
   check_multiplicable("trace_gen_quad_form", "A", A, "B", B);
   check_multiplicable("trace_gen_quad_form", "B", B, "D", D);
-  const auto& B_ref = to_ref(B);
+  const auto &B_ref = to_ref(B);
   return (B_ref * D.transpose()).cwiseProduct(A * B_ref).sum();
 }
 

stan/math/rev/fun/log_softmax.hpp

@@ -58,39 +58,40 @@ class log_softmax_elt_vari : public vari {
  */
 template <typename T, require_container_st<is_var, T>* = nullptr>
 inline auto log_softmax(const T& x) {
-  return apply_vector_unary<ref_type_t<T>>::apply(to_ref(x), [&](const auto& alpha) {
-    const int a_size = alpha.size();
+  return apply_vector_unary<ref_type_t<T>>::apply(
+      to_ref(x), [&](const auto& alpha) {
+        const int a_size = alpha.size();
 
-    check_nonzero_size("log_softmax", "alpha", alpha);
+        check_nonzero_size("log_softmax", "alpha", alpha);
 
-    vari** alpha_vi_array
-        = ChainableStack::instance_->memalloc_.alloc_array<vari*>(a_size);
-    Eigen::Map<vector_vi>(alpha_vi_array, a_size) = alpha.vi();
+        vari** alpha_vi_array
+            = ChainableStack::instance_->memalloc_.alloc_array<vari*>(a_size);
+        Eigen::Map<vector_vi>(alpha_vi_array, a_size) = alpha.vi();
 
-    vector_d alpha_d = alpha.val();
+        vector_d alpha_d = alpha.val();
 
-    // fold logic of math::softmax() and math::log_softmax()
-    // to save computations
+        // fold logic of math::softmax() and math::log_softmax()
+        // to save computations
 
-    vector_d diff = (alpha_d.array() - alpha_d.maxCoeff());
-    vector_d softmax_alpha_d = diff.array().exp();
-    double sum = softmax_alpha_d.sum();
-    vector_d log_softmax_alpha_d = diff.array() - std::log(sum);
+        vector_d diff = (alpha_d.array() - alpha_d.maxCoeff());
+        vector_d softmax_alpha_d = diff.array().exp();
+        double sum = softmax_alpha_d.sum();
+        vector_d log_softmax_alpha_d = diff.array() - std::log(sum);
 
-    // end fold
-    double* softmax_alpha_d_array
-        = ChainableStack::instance_->memalloc_.alloc_array<double>(a_size);
-    Eigen::Map<vector_d>(softmax_alpha_d_array, a_size)
-        = softmax_alpha_d.array() / sum;
+        // end fold
+        double* softmax_alpha_d_array
+            = ChainableStack::instance_->memalloc_.alloc_array<double>(a_size);
+        Eigen::Map<vector_d>(softmax_alpha_d_array, a_size)
+            = softmax_alpha_d.array() / sum;
 
-    vector_v log_softmax_alpha(a_size);
-    for (int k = 0; k < a_size; ++k) {
-      log_softmax_alpha(k) = var(new internal::log_softmax_elt_vari(
-          log_softmax_alpha_d[k], alpha_vi_array, softmax_alpha_d_array, a_size,
-          k));
-    }
-    return log_softmax_alpha;
-  });
+        vector_v log_softmax_alpha(a_size);
+        for (int k = 0; k < a_size; ++k) {
+          log_softmax_alpha(k) = var(new internal::log_softmax_elt_vari(
+              log_softmax_alpha_d[k], alpha_vi_array, softmax_alpha_d_array,
+              a_size, k));
+        }
+        return log_softmax_alpha;
+      });
 }
 
 }  // namespace math

stan/math/rev/fun/mdivide_left_spd.hpp

@@ -144,8 +144,9 @@ class mdivide_left_spd_vd_vari : public vari {
 };
 }  // namespace internal
 
-template <typename EigMat1, typename EigMat2,
-          require_all_eigen_matrix_base_vt<is_var, EigMat1, EigMat2> * = nullptr>
+template <
+    typename EigMat1, typename EigMat2,
+    require_all_eigen_matrix_base_vt<is_var, EigMat1, EigMat2> * = nullptr>
 inline Eigen::Matrix<var, EigMat1::RowsAtCompileTime,
                      EigMat2::ColsAtCompileTime>
 mdivide_left_spd(const EigMat1 &A, const EigMat2 &b) {

stan/math/rev/fun/multiply.hpp

@@ -604,7 +604,8 @@ inline var multiply(const RowVec& m1, const ColVec& m2) {
   check_not_nan("multiply", "m2", m2_ref);
   // Memory managed with the arena allocator.
   multiply_mat_vari<RowVecScalar, 1, Ca, ColVecScalar, 1>* baseVari
-      = new multiply_mat_vari<RowVecScalar, 1, Ca, ColVecScalar, 1>(m1_ref, m2_ref);
+      = new multiply_mat_vari<RowVecScalar, 1, Ca, ColVecScalar, 1>(m1_ref,
+                                                                    m2_ref);
   var AB_v;
   AB_v.vi_ = baseVari->variRefAB_;
   return AB_v;