fix double inline keywords

Author: SteveBronder

stan/math/fwd/fun/hypergeometric_1F0.hpp

@@ -36,10 +36,10 @@ inline FvarT hypergeometric_1F0(const Ta& a, const Tz& z) {
   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_ += forward_as<FvarT>(a).d() * -rtn.val() * log1m(z_val);
+    rtn.d_ += a.d() * -rtn.val() * log1m(z_val);
   }
   if constexpr (is_autodiff_v<Tz>) {
-    rtn.d_ += forward_as<FvarT>(z).d() * rtn.val() * a_val * inv(1 - z_val);
+    rtn.d_ += 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 += forward_as<fvar_t>(a1).d() * std::get<0>(grad_tuple);
+    grad += a1.d() * std::get<0>(grad_tuple);
   }
   if constexpr (is_autodiff_v<Ta2>) {
-    grad += forward_as<fvar_t>(a2).d() * std::get<1>(grad_tuple);
+    grad += a2.d() * std::get<1>(grad_tuple);
   }
   if constexpr (is_autodiff_v<Tb>) {
-    grad += forward_as<fvar_t>(b).d() * std::get<2>(grad_tuple);
+    grad += b.d() * std::get<2>(grad_tuple);
   }
   if constexpr (is_autodiff_v<Tz>) {
-    grad += forward_as<fvar_t>(z).d() * std::get<3>(grad_tuple);
+    grad += 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_ += forward_as<fvar<T_return>>(a).d_ * da1 * (da2 - da3);
+    inv_d_ += a.d_ * da1 * (da2 - da3);
   }
 
   if constexpr (is_fvar<T2>::value) {
@@ -76,12 +76,11 @@ 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_ += forward_as<fvar<T_return>>(b).d_ * db1 * (exp(db2) - db3);
+    inv_d_ += b.d_ * db1 * (exp(db2) - db3);
   }
 
   if constexpr (is_fvar<T3>::value) {
-    inv_d_ += forward_as<fvar<T_return>>(p).d_
-              * exp(one_m_b * log1m_w + one_m_a * log_w + lbeta_ab);
+    inv_d_ += 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/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_ += math::forward_as<FvarT>(a).d_
+      ret.d_ += 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_ += math::forward_as<FvarT>(b).d_
+      ret.d_ += b.d_
                 * math::apply(
                     [&](auto &&... tuple_args) {
                       return f(b_val, 0.0, msgs, tuple_args...);

stan/math/opencl/prim/bernoulli_logit_glm_lpmf.hpp

@@ -144,8 +144,7 @@ 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 {
-      forward_as<internal::broadcast_array<double>>(
-          partials<1>(ops_partials))[0]
+      partials<1>(ops_partials)[0]
           = sum(from_matrix_cl(theta_derivative_sum_cl));
     }
   }

stan/math/opencl/prim/bernoulli_lpmf.hpp

@@ -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(forward_as<matrix_cl<int>>(n));
+    auto n_sum_expr = rowwise_sum(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 = forward_as<double>(theta_val);
+    double theta_val_scal = theta_val;
     if (n_sum == N) {
       logp = N * log(theta_val_scal);
     } else if (n_sum == 0) {
@@ -94,8 +94,7 @@ 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 = forward_as<internal::broadcast_array<double>>(
-          partials<0>(ops_partials))[0];
+      double& edge1_partial = partials<0>(ops_partials)[0];
       if (n_sum == N) {
         edge1_partial += N / theta_val_scal;
       } else if (n_sum == 0) {

stan/math/opencl/prim/binomial_logit_glm_lpmf.hpp

@@ -111,9 +111,7 @@ 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 {
-      forward_as<internal::broadcast_array<double>>(
-          partials<1>(ops_partials))[0]
-          = sum(from_matrix_cl(theta_deriv_sum_cl));
+      partials<1>(ops_partials)[0] = sum(from_matrix_cl(theta_deriv_sum_cl));
     }
   }
   if constexpr (is_autodiff_v<T_beta_cl>) {

stan/math/opencl/prim/binomial_lpmf.hpp

@@ -113,9 +113,8 @@ inline return_type_t<T_prob_cl> binomial_lpmf(const T_n_cl& n, const T_N_cl N,
     if constexpr (need_sums) {
       int sum_n = sum(from_matrix_cl(sum_n_cl));
       int sum_N = sum(from_matrix_cl(sum_N_cl));
-      double theta_dbl = forward_as<double>(theta_val);
-      double& partial = forward_as<internal::broadcast_array<double>>(
-          partials<0>(ops_partials))[0];
+      double theta_dbl = theta_val;
+      double& partial = partials<0>(ops_partials)[0];
       if (sum_N != 0) {
         if (sum_n == 0) {
           partial = -sum_N / (1.0 - theta_dbl);

stan/math/opencl/prim/categorical_logit_glm_lpmf.hpp

@@ -88,8 +88,8 @@ inline return_type_t<T_x, T_alpha, T_beta> categorical_logit_glm_lpmf(
       = opencl_kernels::categorical_logit_glm.get_option("LOCAL_SIZE_");
   const int wgs = (N_instances + local_size - 1) / local_size;
 
-  bool need_alpha_derivative = is_autodiff_v<T_alpha>;
-  bool need_beta_derivative = is_autodiff_v<T_beta>;
+  constexpr bool need_alpha_derivative = is_autodiff_v<T_alpha>;
+  constexpr bool need_beta_derivative = is_autodiff_v<T_beta>;
 
   matrix_cl<double> logp_cl(wgs, 1);
   matrix_cl<double> exp_lin_cl(N_instances, N_classes);
@@ -127,13 +127,12 @@ inline return_type_t<T_x, T_alpha, T_beta> categorical_logit_glm_lpmf(
     if constexpr (is_y_vector) {
       partials<0>(ops_partials)
           = indexing(beta_val, col_index(x.rows(), x.cols()),
-                     rowwise_broadcast(forward_as<matrix_cl<int>>(y_val) - 1))
+                     rowwise_broadcast(y_val - 1))
             - elt_multiply(exp_lin_cl * transpose(beta_val),
                            rowwise_broadcast(inv_sum_exp_lin_cl));
     } else {
       partials<0>(ops_partials)
-          = indexing(beta_val, col_index(x.rows(), x.cols()),
-                     forward_as<int>(y_val) - 1)
+          = indexing(beta_val, col_index(x.rows(), x.cols()), y_val - 1)
             - elt_multiply(exp_lin_cl * transpose(beta_val),
                            rowwise_broadcast(inv_sum_exp_lin_cl));
     }
@@ -152,9 +151,8 @@ inline return_type_t<T_x, T_alpha, T_beta> categorical_logit_glm_lpmf(
       try {
         opencl_kernels::categorical_logit_glm_beta_derivative(
             cl::NDRange(local_size * N_attributes), cl::NDRange(local_size),
-            forward_as<arena_matrix_cl<double>>(partials<2>(ops_partials)),
-            temp, y_val_cl, x_val, N_instances, N_attributes, N_classes,
-            is_y_vector);
+            partials<2>(ops_partials), temp, y_val_cl, x_val, N_instances,
+            N_attributes, N_classes, is_y_vector);
       } catch (const cl::Error& e) {
         check_opencl_error(function, e);
       }

stan/math/opencl/prim/neg_binomial_2_log_glm_lpmf.hpp

@@ -168,14 +168,11 @@ neg_binomial_2_log_glm_lpmf(const T_y_cl& y, const T_x_cl& x,
   }
 
   if constexpr (include_summand<propto, T_phi_cl>::value && !is_phi_vector) {
-    logp += N
-            * (multiply_log(forward_as<double>(phi_val),
-                            forward_as<double>(phi_val))
-               - lgamma(forward_as<double>(phi_val)));
+    logp += N * (multiply_log(phi_val, phi_val) - lgamma(phi_val));
   }
   if constexpr (include_summand<propto, T_phi_cl>::value && !is_y_vector
                 && !is_phi_vector) {
-    logp += forward_as<double>(lgamma(y_val + phi_val)) * N;
+    logp += lgamma(y_val + phi_val) * N;
   }
 
   auto ops_partials = make_partials_propagator(x, alpha, beta, phi);
@@ -203,18 +200,15 @@ neg_binomial_2_log_glm_lpmf(const T_y_cl& y, const T_x_cl& x,
     if constexpr (is_alpha_vector) {
       partials<1>(ops_partials) = std::move(theta_derivative_cl);
     } else {
-      forward_as<internal::broadcast_array<double>>(
-          partials<1>(ops_partials))[0]
+      partials<1>(ops_partials)[0]
           = sum(from_matrix_cl(theta_derivative_sum_cl));
     }
   }
   if constexpr (is_autodiff_v<T_phi_cl>) {
     if constexpr (is_phi_vector) {
       partials<3>(ops_partials) = std::move(phi_derivative_cl);
     } else {
-      forward_as<internal::broadcast_array<double>>(
-          partials<3>(ops_partials))[0]
-          = sum(from_matrix_cl(phi_derivative_cl));
+      partials<3>(ops_partials)[0] = sum(from_matrix_cl(phi_derivative_cl));
     }
   }
   return ops_partials.build(logp);