Feature/issue 2966 add 7 parameter ddm cdf and ccdf

stan/math/fwd/fun/hypergeometric_1F0.hpp

@@ -31,15 +31,15 @@ namespace math {
 template <typename Ta, typename Tz, typename FvarT = return_type_t<Ta, Tz>,
           require_all_stan_scalar_t<Ta, Tz>* = nullptr,
           require_any_fvar_t<Ta, Tz>* = nullptr>
-inline FvarT hypergeometric_1F0(const Ta& a, const Tz& z) {
+FvarT hypergeometric_1F0(const Ta& a, const Tz& z) {
   partials_type_t<Ta> a_val = value_of(a);
   partials_type_t<Tz> z_val = value_of(z);
   FvarT rtn = FvarT(hypergeometric_1F0(a_val, z_val), 0.0);
   if constexpr (is_autodiff_v<Ta>) {
-    rtn.d_ += a.d() * -rtn.val() * log1m(z_val);
+    rtn.d_ += forward_as<FvarT>(a).d() * -rtn.val() * log1m(z_val);
   }
   if constexpr (is_autodiff_v<Tz>) {
-    rtn.d_ += z.d() * rtn.val() * a_val * inv(1 - z_val);
+    rtn.d_ += forward_as<FvarT>(z).d() * rtn.val() * a_val * inv(1 - z_val);
   }
   return rtn;
 }

stan/math/fwd/fun/hypergeometric_2F1.hpp

@@ -46,16 +46,16 @@ inline return_type_t<Ta1, Ta2, Tb, Tz> hypergeometric_2F1(const Ta1& a1,
   typename fvar_t::Scalar grad = 0;
 
   if constexpr (is_autodiff_v<Ta1>) {
-    grad += a1.d() * std::get<0>(grad_tuple);
+    grad += forward_as<fvar_t>(a1).d() * std::get<0>(grad_tuple);
   }
   if constexpr (is_autodiff_v<Ta2>) {
-    grad += a2.d() * std::get<1>(grad_tuple);
+    grad += forward_as<fvar_t>(a2).d() * std::get<1>(grad_tuple);
   }
   if constexpr (is_autodiff_v<Tb>) {
-    grad += b.d() * std::get<2>(grad_tuple);
+    grad += forward_as<fvar_t>(b).d() * std::get<2>(grad_tuple);
   }
   if constexpr (is_autodiff_v<Tz>) {
-    grad += z.d() * std::get<3>(grad_tuple);
+    grad += forward_as<fvar_t>(z).d() * std::get<3>(grad_tuple);
   }
 
   return fvar_t(hypergeometric_2F1(a1_val, a2_val, b_val, z_val), grad);

stan/math/fwd/fun/inv_inc_beta.hpp

@@ -63,7 +63,7 @@ inline fvar<partials_return_t<T1, T2, T3>> inv_inc_beta(const T1& a,
                    + log(hypergeometric_3F2(da_a, da_b, w)) - 2 * lgamma(ap1));
     auto da3 = inc_beta(a_val, b_val, w) * exp(lbeta_ab)
                * (log_w - digamma(a_val) + digamma_apb);
-    inv_d_ += a.d_ * da1 * (da2 - da3);
+    inv_d_ += forward_as<fvar<T_return>>(a).d_ * da1 * (da2 - da3);
   }
 
   if constexpr (is_fvar<T2>::value) {
@@ -76,11 +76,12 @@ inline fvar<partials_return_t<T1, T2, T3>> inv_inc_beta(const T1& a,
     auto db3 = inc_beta(b_val, a_val, one_m_w) * exp(lbeta_ab)
                * (log1m_w - digamma(b_val) + digamma_apb);
 
-    inv_d_ += b.d_ * db1 * (exp(db2) - db3);
+    inv_d_ += forward_as<fvar<T_return>>(b).d_ * db1 * (exp(db2) - db3);
   }
 
   if constexpr (is_fvar<T3>::value) {
-    inv_d_ += p.d_ * exp(one_m_b * log1m_w + one_m_a * log_w + lbeta_ab);
+    inv_d_ += forward_as<fvar<T_return>>(p).d_
+              * exp(one_m_b * log1m_w + one_m_a * log_w + lbeta_ab);
   }
 
   return fvar<T_return>(w, inv_d_);

stan/math/fwd/fun/polar.hpp

@@ -44,7 +44,7 @@ inline std::complex<fvar<T>> polar(const fvar<T>& r, U theta) {
  * Returns complex number with specified magnitude and phase angle.
  *
  * @tparam T autodiff value type for phase angle
- * * @tparam U arithmetic type for magnitude
++* * @tparam U arithmetic type for magnitude
  * @param[in] r magnitude
  * @param[in] theta phase angle
  * @return complex number with magnitude and phase angle

stan/math/fwd/functor/gradient.hpp

@@ -37,8 +37,8 @@ namespace math {
  * @param[out] grad_fx Gradient of function at argument
  */
 template <typename T, typename F>
-inline void gradient(const F& f, const Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
-                     T& fx, Eigen::Matrix<T, Eigen::Dynamic, 1>& grad_fx) {
+void gradient(const F& f, const Eigen::Matrix<T, Eigen::Dynamic, 1>& x, T& fx,
+              Eigen::Matrix<T, Eigen::Dynamic, 1>& grad_fx) {
   Eigen::Matrix<fvar<T>, Eigen::Dynamic, 1> x_fvar(x.size());
   grad_fx.resize(x.size());
   for (int i = 0; i < x.size(); ++i) {

stan/math/fwd/functor/hessian.hpp

@@ -38,9 +38,9 @@ namespace math {
  * @param[out] H Hessian of function at argument
  */
 template <typename T, typename F>
-inline void hessian(const F& f, const Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
-                    T& fx, Eigen::Matrix<T, Eigen::Dynamic, 1>& grad,
-                    Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& H) {
+void hessian(const F& f, const Eigen::Matrix<T, Eigen::Dynamic, 1>& x, T& fx,
+             Eigen::Matrix<T, Eigen::Dynamic, 1>& grad,
+             Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& H) {
   H.resize(x.size(), x.size());
   grad.resize(x.size());
   // size 0 separate because nothing to loop over in main body

stan/math/fwd/functor/integrate_1d.hpp

@@ -48,15 +48,15 @@ inline return_type_t<T_a, T_b, Args...> integrate_1d_impl(
   if constexpr (is_fvar<T_a>::value || is_fvar<T_b>::value) {
     auto val_args = std::make_tuple(value_of(args)...);
     if constexpr (is_fvar<T_a>::value) {
-      ret.d_ += a.d_
+      ret.d_ += math::forward_as<FvarT>(a).d_
                 * math::apply(
                     [&](auto &&... tuple_args) {
                       return -f(a_val, 0.0, msgs, tuple_args...);
                     },
                     val_args);
     }
     if constexpr (is_fvar<T_b>::value) {
-      ret.d_ += b.d_
+      ret.d_ += math::forward_as<FvarT>(b).d_
                 * math::apply(
                     [&](auto &&... tuple_args) {
                       return f(b_val, 0.0, msgs, tuple_args...);

stan/math/fwd/functor/jacobian.hpp

@@ -8,9 +8,9 @@ namespace stan {
 namespace math {
 
 template <typename T, typename F>
-inline void jacobian(const F& f, const Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
-                     Eigen::Matrix<T, Eigen::Dynamic, 1>& fx,
-                     Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& J) {
+void jacobian(const F& f, const Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
+              Eigen::Matrix<T, Eigen::Dynamic, 1>& fx,
+              Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& J) {
   using Eigen::Dynamic;
   using Eigen::Matrix;
   Matrix<fvar<T>, Dynamic, 1> x_fvar(x.size());

stan/math/memory/stack_alloc.hpp

@@ -26,7 +26,7 @@ namespace math {
  * @tparam Type of object to which pointer points.
  */
 template <typename T>
-inline bool is_aligned(T* ptr, unsigned int bytes_aligned) {
+bool is_aligned(T* ptr, unsigned int bytes_aligned) {
   return (reinterpret_cast<uintptr_t>(ptr) % bytes_aligned) == 0U;
 }
 

stan/math/mix/functor/hessian_times_vector.hpp

@@ -38,10 +38,10 @@ inline void hessian_times_vector(
 template <typename T, typename F, typename EigVec,
           require_eigen_vector_t<EigVec>* = nullptr,
           require_stan_scalar_t<T>* = nullptr>
-inline void hessian_times_vector(const F& f,
-                                 const Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
-                                 const EigVec& v, T& fx,
-                                 Eigen::Matrix<T, Eigen::Dynamic, 1>& Hv) {
+void hessian_times_vector(const F& f,
+                          const Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
+                          const EigVec& v, T& fx,
+                          Eigen::Matrix<T, Eigen::Dynamic, 1>& Hv) {
   using Eigen::Matrix;
   Matrix<T, Eigen::Dynamic, 1> grad;
   Matrix<T, Eigen::Dynamic, Eigen::Dynamic> H;

stan/math/mix/functor/partial_derivative.hpp

@@ -22,9 +22,9 @@ namespace math {
  * @param[out] dfx_dxn Value of partial derivative
  */
 template <typename T, typename F>
-inline void partial_derivative(const F& f,
-                               const Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
-                               int n, T& fx, T& dfx_dxn) {
+void partial_derivative(const F& f,
+                        const Eigen::Matrix<T, Eigen::Dynamic, 1>& x, int n,
+                        T& fx, T& dfx_dxn) {
   Eigen::Matrix<fvar<T>, Eigen::Dynamic, 1> x_fvar(x.size());
   for (int i = 0; i < x.size(); ++i) {
     x_fvar(i) = fvar<T>(x(i), i == n);

stan/math/opencl/copy.hpp

@@ -232,7 +232,7 @@ inline T_dst from_matrix_cl(const matrix_cl<T>& src) {
  * @return Eigen matrix with a copy of the data in the source matrix
  */
 template <typename T, require_all_kernel_expressions_t<T>* = nullptr>
-inline auto from_matrix_cl(const T& src) {
+auto from_matrix_cl(const T& src) {
   return from_matrix_cl<
       Eigen::Matrix<scalar_type_t<T>, Eigen::Dynamic, Eigen::Dynamic>>(src);
 }

stan/math/opencl/indexing_rev.hpp

@@ -19,8 +19,8 @@ namespace math {
  * @param idx indices
  * @param res adjoint of the result of the indexing operation
  */
-inline void indexing_rev(matrix_cl<double>& adj, const matrix_cl<int>& idx,
-                         const matrix_cl<double>& res) {
+void indexing_rev(matrix_cl<double>& adj, const matrix_cl<int>& idx,
+                  const matrix_cl<double>& res) {
   int local_mem_size
       = opencl_context.device()[0].getInfo<CL_DEVICE_LOCAL_MEM_SIZE>();
   int preferred_work_groups

stan/math/opencl/kernel_generator/evaluate_into.hpp

@@ -18,8 +18,7 @@ namespace math {
  */
 template <typename Derived, typename Scalar, typename... Args>
 template <typename T_lhs>
-inline void operation_cl<Derived, Scalar, Args...>::evaluate_into(
-    T_lhs& lhs) const {
+void operation_cl<Derived, Scalar, Args...>::evaluate_into(T_lhs& lhs) const {
   static_assert(
       is_kernel_expression<T_lhs>::value,
       "operation_cl::evaluate_into: left hand side is not a valid expression!");

stan/math/opencl/kernel_generator/holder_cl.hpp

@@ -64,7 +64,7 @@ class holder_cl_
  */
 template <typename T, typename... Ptrs,
           require_all_kernel_expressions_t<T, Ptrs...>* = nullptr>
-inline auto holder_cl(T&& a, Ptrs*... ptrs) {
+auto holder_cl(T&& a, Ptrs*... ptrs) {
   return holder_cl_<as_operation_cl_t<T>, Ptrs...>(
       as_operation_cl(std::forward<T>(a)), ptrs...);
 }
@@ -81,8 +81,8 @@ namespace internal {
  * @return `holder_cl` referencing given expression
  */
 template <typename T, std::size_t... Is, typename... Args>
-inline auto make_holder_cl_impl_step2(T&& expr, std::index_sequence<Is...>,
-                                      const std::tuple<Args*...>& ptrs) {
+auto make_holder_cl_impl_step2(T&& expr, std::index_sequence<Is...>,
+                               const std::tuple<Args*...>& ptrs) {
   return holder_cl(std::forward<T>(expr), std::get<Is>(ptrs)...);
 }
 
@@ -96,8 +96,8 @@ inline auto make_holder_cl_impl_step2(T&& expr, std::index_sequence<Is...>,
  * @return `holder_cl` referencing given expression
  */
 template <typename T, std::size_t... Is, typename... Args>
-inline auto make_holder_cl_impl_step1(const T& func, std::index_sequence<Is...>,
-                                      Args&&... args) {
+auto make_holder_cl_impl_step1(const T& func, std::index_sequence<Is...>,
+                               Args&&... args) {
   std::tuple<std::remove_reference_t<Args>*...> res;
   auto ptrs = std::tuple_cat(
       holder_handle_element(std::forward<Args>(args), std::get<Is>(res))...);
@@ -122,7 +122,7 @@ template <typename T, typename... Args,
           require_all_kernel_expressions_t<
               decltype(std::declval<T>()(std::declval<Args&>()...)),
               Args...>* = nullptr>
-inline auto make_holder_cl(const T& func, Args&&... args) {
+auto make_holder_cl(const T& func, Args&&... args) {
   return internal::make_holder_cl_impl_step1(
       func, std::make_index_sequence<sizeof...(Args)>(),
       std::forward<Args>(args)...);

stan/math/opencl/kernel_generator/multi_result_kernel.hpp

@@ -665,7 +665,7 @@ class results_cl {
  * @param results results that will be calculated in same kernel.
  */
 template <typename... T_results>
-inline results_cl<T_results...> results(T_results&&... results) {
+results_cl<T_results...> results(T_results&&... results) {
   return results_cl<T_results...>(std::forward<T_results>(results)...);
 }
 

stan/math/opencl/prim/bernoulli_cdf.hpp

@@ -27,8 +27,8 @@ template <
     typename T_n_cl, typename T_prob_cl,
     require_all_prim_or_rev_kernel_expression_t<T_n_cl, T_prob_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_n_cl, T_prob_cl>* = nullptr>
-inline return_type_t<T_prob_cl> bernoulli_cdf(const T_n_cl& n,
-                                              const T_prob_cl& theta) {
+return_type_t<T_prob_cl> bernoulli_cdf(const T_n_cl& n,
+                                       const T_prob_cl& theta) {
   static constexpr const char* function = "bernoulli_cdf(OpenCL)";
   using T_partials_return = partials_return_t<T_prob_cl>;
   using std::isnan;

stan/math/opencl/prim/bernoulli_lccdf.hpp

@@ -28,8 +28,8 @@ template <
     typename T_n_cl, typename T_prob_cl,
     require_all_prim_or_rev_kernel_expression_t<T_n_cl, T_prob_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_n_cl, T_prob_cl>* = nullptr>
-inline return_type_t<T_prob_cl> bernoulli_lccdf(const T_n_cl& n,
-                                                const T_prob_cl& theta) {
+return_type_t<T_prob_cl> bernoulli_lccdf(const T_n_cl& n,
+                                         const T_prob_cl& theta) {
   static constexpr const char* function = "bernoulli_lccdf(OpenCL)";
   using T_partials_return = partials_return_t<T_prob_cl>;
   using std::isnan;

stan/math/opencl/prim/bernoulli_lcdf.hpp

@@ -28,8 +28,8 @@ template <
     typename T_n_cl, typename T_prob_cl,
     require_all_prim_or_rev_kernel_expression_t<T_n_cl, T_prob_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_n_cl, T_prob_cl>* = nullptr>
-inline return_type_t<T_prob_cl> bernoulli_lcdf(const T_n_cl& n,
-                                               const T_prob_cl& theta) {
+return_type_t<T_prob_cl> bernoulli_lcdf(const T_n_cl& n,
+                                        const T_prob_cl& theta) {
   static constexpr const char* function = "bernoulli_lcdf(OpenCL)";
   using T_partials_return = partials_return_t<T_prob_cl>;
   using std::isnan;

stan/math/opencl/prim/bernoulli_logit_glm_lpmf.hpp

@@ -53,7 +53,7 @@ template <bool propto, typename T_x_cl, typename T_y_cl, typename T_alpha_cl,
           typename T_beta_cl,
           require_all_prim_or_rev_kernel_expression_t<
               T_y_cl, T_x_cl, T_alpha_cl, T_beta_cl>* = nullptr>
-inline return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> bernoulli_logit_glm_lpmf(
+return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> bernoulli_logit_glm_lpmf(
     const T_y_cl& y, const T_x_cl& x, const T_alpha_cl& alpha,
     const T_beta_cl& beta) {
   static constexpr const char* function = "bernoulli_logit_glm_lpmf(OpenCL)";
@@ -144,7 +144,8 @@ inline return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> bernoulli_logit_glm_lpmf(
     if constexpr (is_alpha_vector) {
       partials<1>(ops_partials) = theta_derivative_cl;
     } else {
-      partials<1>(ops_partials)[0]
+      forward_as<internal::broadcast_array<double>>(
+          partials<1>(ops_partials))[0]
           = sum(from_matrix_cl(theta_derivative_sum_cl));
     }
   }

stan/math/opencl/prim/bernoulli_logit_lpmf.hpp

@@ -26,8 +26,8 @@ template <
     bool propto, typename T_n_cl, typename T_prob_cl,
     require_all_prim_or_rev_kernel_expression_t<T_n_cl, T_prob_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_n_cl, T_prob_cl>* = nullptr>
-inline return_type_t<T_prob_cl> bernoulli_logit_lpmf(const T_n_cl& n,
-                                                     const T_prob_cl& theta) {
+return_type_t<T_prob_cl> bernoulli_logit_lpmf(const T_n_cl& n,
+                                              const T_prob_cl& theta) {
   static constexpr const char* function = "bernoulli_logit_lpmf(OpenCL)";
   using T_partials_return = partials_return_t<T_prob_cl>;
   using std::isnan;

stan/math/opencl/prim/bernoulli_lpmf.hpp

@@ -29,8 +29,8 @@ template <
     bool propto, typename T_n_cl, typename T_prob_cl,
     require_all_prim_or_rev_kernel_expression_t<T_n_cl, T_prob_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_n_cl, T_prob_cl>* = nullptr>
-inline return_type_t<T_prob_cl> bernoulli_lpmf(const T_n_cl& n,
-                                               const T_prob_cl& theta) {
+return_type_t<T_prob_cl> bernoulli_lpmf(const T_n_cl& n,
+                                        const T_prob_cl& theta) {
   static constexpr const char* function = "bernoulli_lpmf(OpenCL)";
   using T_partials_return = partials_return_t<T_prob_cl>;
   constexpr bool is_n_vector = !is_stan_scalar<T_n_cl>::value;
@@ -77,15 +77,15 @@ inline return_type_t<T_prob_cl> bernoulli_lpmf(const T_n_cl& n,
       partials<0>(ops_partials) = deriv_cl;
     }
   } else {
-    auto n_sum_expr = rowwise_sum(n);
+    auto n_sum_expr = rowwise_sum(forward_as<matrix_cl<int>>(n));
 
     matrix_cl<int> n_sum_cl;
 
     results(n_sum_cl, check_n_bounded)
         = expressions(n_sum_expr, n_bounded_expr);
 
     size_t n_sum = sum(from_matrix_cl(n_sum_cl));
-    double theta_val_scal = theta_val;
+    double theta_val_scal = forward_as<double>(theta_val);
     if (n_sum == N) {
       logp = N * log(theta_val_scal);
     } else if (n_sum == 0) {
@@ -94,7 +94,8 @@ inline return_type_t<T_prob_cl> bernoulli_lpmf(const T_n_cl& n,
       logp = n_sum * log(theta_val_scal) + (N - n_sum) * log1m(theta_val_scal);
     }
     if constexpr (is_autodiff_v<T_prob_cl>) {
-      double& edge1_partial = partials<0>(ops_partials)[0];
+      double& edge1_partial = forward_as<internal::broadcast_array<double>>(
+          partials<0>(ops_partials))[0];
       if (n_sum == N) {
         edge1_partial += N / theta_val_scal;
       } else if (n_sum == 0) {

stan/math/opencl/prim/beta_binomial_lpmf.hpp

@@ -40,7 +40,7 @@ template <
     require_all_prim_or_rev_kernel_expression_t<T_n_cl, T_size1_cl,
                                                 T_size2_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_n_cl, T_size1_cl, T_size2_cl>* = nullptr>
-inline return_type_t<T_n_cl, T_size1_cl, T_size2_cl> beta_binomial_lpmf(
+return_type_t<T_n_cl, T_size1_cl, T_size2_cl> beta_binomial_lpmf(
     const T_n_cl& n, const T_N_cl N, const T_size1_cl& alpha,
     const T_size2_cl& beta) {
   using std::isfinite;

stan/math/opencl/prim/beta_lpdf.hpp

@@ -40,7 +40,7 @@ template <bool propto, typename T_y_cl, typename T_scale_succ_cl,
               T_y_cl, T_scale_succ_cl, T_scale_fail_cl>* = nullptr,
           require_any_not_stan_scalar_t<T_y_cl, T_scale_succ_cl,
                                         T_scale_fail_cl>* = nullptr>
-inline return_type_t<T_y_cl, T_scale_succ_cl, T_scale_fail_cl> beta_lpdf(
+return_type_t<T_y_cl, T_scale_succ_cl, T_scale_fail_cl> beta_lpdf(
     const T_y_cl& y, const T_scale_succ_cl& alpha,
     const T_scale_fail_cl& beta) {
   using std::isfinite;

stan/math/opencl/prim/beta_proportion_lpdf.hpp

@@ -39,7 +39,7 @@ template <bool propto, typename T_y_cl, typename T_loc_cl, typename T_prec_cl,
           require_all_prim_or_rev_kernel_expression_t<T_y_cl, T_loc_cl,
                                                       T_prec_cl>* = nullptr,
           require_any_not_stan_scalar_t<T_y_cl, T_loc_cl, T_prec_cl>* = nullptr>
-inline return_type_t<T_y_cl, T_loc_cl, T_prec_cl> beta_proportion_lpdf(
+return_type_t<T_y_cl, T_loc_cl, T_prec_cl> beta_proportion_lpdf(
     const T_y_cl& y, const T_loc_cl& mu, const T_prec_cl& kappa) {
   static constexpr const char* function = "beta_proportion_lpdf(OpenCL)";
   using T_partials_return = partials_return_t<T_y_cl, T_loc_cl, T_prec_cl>;

stan/math/opencl/prim/binomial_logit_glm_lpmf.hpp

@@ -29,7 +29,7 @@ template <bool propto, typename T_n_cl, typename T_N_cl, typename T_x_cl,
           typename T_alpha_cl, typename T_beta_cl,
           require_all_prim_or_rev_kernel_expression_t<
               T_n_cl, T_N_cl, T_x_cl, T_alpha_cl, T_beta_cl>* = nullptr>
-inline return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> binomial_logit_glm_lpmf(
+return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> binomial_logit_glm_lpmf(
     const T_n_cl& n, const T_N_cl& N, const T_x_cl& x, const T_alpha_cl& alpha,
     const T_beta_cl& beta) {
   static const char* function = "binomial_logit_glm_lpmf(OpenCL)";
@@ -111,7 +111,9 @@ inline return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> binomial_logit_glm_lpmf(
     if constexpr (is_alpha_vector) {
       partials<1>(ops_partials) = theta_deriv_cl;
     } else {
-      partials<1>(ops_partials)[0] = sum(from_matrix_cl(theta_deriv_sum_cl));
+      forward_as<internal::broadcast_array<double>>(
+          partials<1>(ops_partials))[0]
+          = sum(from_matrix_cl(theta_deriv_sum_cl));
     }
   }
   if constexpr (is_autodiff_v<T_beta_cl>) {