Revert extra backports

Author: andrjohns

stan/math/opencl/zeros_strict_tri.hpp

@@ -9,7 +9,7 @@
 #include <stan/math/opencl/kernels/fill_strict_tri.hpp>
 #include <stan/math/prim/meta.hpp>
 
-#include <CL/opencl.hpp>
+#include <CL/cl2.hpp>
 
 namespace stan {
 namespace math {
@@ -29,7 +29,7 @@ namespace math {
  */
 template <typename T>
 template <matrix_cl_view matrix_view>
-inline void matrix_cl<T>::zeros_strict_tri() try {
+inline void matrix_cl<T, require_arithmetic_t<T>>::zeros_strict_tri() try {
   if (matrix_view == matrix_cl_view::Entire) {
     invalid_argument(
         "zeros_strict_tri", "matrix_view",

stan/math/prim/fun/offset_multiplier_constrain.hpp

@@ -7,9 +7,6 @@
 #include <stan/math/prim/fun/identity_constrain.hpp>
 #include <stan/math/prim/fun/multiply_log.hpp>
 #include <stan/math/prim/fun/size.hpp>
-#include <stan/math/prim/fun/sum.hpp>
-#include <stan/math/prim/fun/to_ref.hpp>
-#include <stan/math/prim/functor/apply.hpp>
 #include <cmath>
 
 namespace stan {
@@ -38,27 +35,19 @@ namespace math {
  * @throw std::domain_error if sigma <= 0
  * @throw std::domain_error if mu is not finite
  */
-template <typename T, typename M, typename S,
-          require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              T, M, S>* = nullptr>
-inline auto offset_multiplier_constrain(const T& x, const M& mu,
-                                        const S& sigma) {
-  const auto& mu_ref = to_ref(mu);
-  const auto& sigma_ref = to_ref(sigma);
-  if (is_matrix<T>::value && is_matrix<M>::value) {
-    check_matching_dims("offset_multiplier_constrain", "x", x, "mu", mu);
-  }
-  if (is_matrix<T>::value && is_matrix<S>::value) {
-    check_matching_dims("offset_multiplier_constrain", "x", x, "sigma", sigma);
-  } else if (is_matrix<M>::value && is_matrix<S>::value) {
-    check_matching_dims("offset_multiplier_constrain", "mu", mu, "sigma",
-                        sigma);
+template <typename T, typename M, typename S>
+inline return_type_t<T, M, S> offset_multiplier_constrain(const T& x,
+                                                          const M& mu,
+                                                          const S& sigma) {
+  check_finite("offset_multiplier_constrain", "offset", mu);
+  if (sigma == 1) {
+    if (mu == 0) {
+      return identity_constrain(x);
+    }
+    return mu + x;
   }
-
-  check_finite("offset_multiplier_constrain", "offset", value_of_rec(mu_ref));
-  check_positive_finite("offset_multiplier_constrain", "multiplier",
-                        value_of_rec(sigma_ref));
-  return fma(sigma_ref, x, mu_ref);
+  check_positive_finite("offset_multiplier_constrain", "multiplier", sigma);
+  return fma(sigma, x, mu);
 }
 
 /**
@@ -87,223 +76,22 @@ inline auto offset_multiplier_constrain(const T& x, const M& mu,
  * @throw std::domain_error if sigma <= 0
  * @throw std::domain_error if mu is not finite
  */
-template <typename T, typename M, typename S,
-          require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              T, M, S>* = nullptr>
-inline auto offset_multiplier_constrain(const T& x, const M& mu, const S& sigma,
-                                        return_type_t<T, M, S>& lp) {
-  const auto& mu_ref = to_ref(mu);
-  const auto& sigma_ref = to_ref(sigma);
-  if (is_matrix<T>::value && is_matrix<M>::value) {
-    check_matching_dims("offset_multiplier_constrain", "x", x, "mu", mu);
-  }
-  if (is_matrix<T>::value && is_matrix<S>::value) {
-    check_matching_dims("offset_multiplier_constrain", "x", x, "sigma", sigma);
-  } else if (is_matrix<M>::value && is_matrix<S>::value) {
-    check_matching_dims("offset_multiplier_constrain", "mu", mu, "sigma",
-                        sigma);
-  }
-
-  check_finite("offset_multiplier_constrain", "offset", value_of_rec(mu_ref));
-  check_positive_finite("offset_multiplier_constrain", "multiplier",
-                        value_of_rec(sigma_ref));
-  if (math::size(sigma_ref) == 1) {
-    lp += sum(multiply_log(math::size(x), sigma_ref));
-  } else {
-    lp += sum(log(sigma_ref));
-  }
-  return fma(sigma_ref, x, mu_ref);
-}
-
-/**
- * Overload for array of x and non-array mu and sigma
- */
-template <typename T, typename M, typename S,
-          require_all_not_std_vector_t<M, S>* = nullptr>
-inline auto offset_multiplier_constrain(const std::vector<T>& x, const M& mu,
-                                        const S& sigma) {
-  std::vector<
-      plain_type_t<decltype(offset_multiplier_constrain(x[0], mu, sigma))>>
-      ret;
-  ret.reserve(x.size());
-  const auto& mu_ref = to_ref(mu);
-  const auto& sigma_ref = to_ref(sigma);
-  for (size_t i = 0; i < x.size(); ++i) {
-    ret.emplace_back(offset_multiplier_constrain(x[i], mu_ref, sigma_ref));
-  }
-  return ret;
-}
-
-/**
- * Overload for array of x and non-array mu and sigma with lp
- */
-template <typename T, typename M, typename S,
-          require_all_not_std_vector_t<M, S>* = nullptr>
-inline auto offset_multiplier_constrain(const std::vector<T>& x, const M& mu,
-                                        const S& sigma,
-                                        return_type_t<T, M, S>& lp) {
-  std::vector<
-      plain_type_t<decltype(offset_multiplier_constrain(x[0], mu, sigma, lp))>>
-      ret;
-  ret.reserve(x.size());
-  const auto& mu_ref = to_ref(mu);
-  const auto& sigma_ref = to_ref(sigma);
-  for (size_t i = 0; i < x.size(); ++i) {
-    ret.emplace_back(offset_multiplier_constrain(x[i], mu_ref, sigma_ref, lp));
-  }
-  return ret;
-}
-
-/**
- * Overload for array of x and sigma and non-array mu
- */
-template <typename T, typename M, typename S,
-          require_not_std_vector_t<M>* = nullptr>
-inline auto offset_multiplier_constrain(const std::vector<T>& x, const M& mu,
-                                        const std::vector<S>& sigma) {
-  check_matching_dims("offset_multiplier_constrain", "x", x, "sigma", sigma);
-  std::vector<
-      plain_type_t<decltype(offset_multiplier_constrain(x[0], mu, sigma[0]))>>
-      ret;
-  ret.reserve(x.size());
-  const auto& mu_ref = to_ref(mu);
-  for (size_t i = 0; i < x.size(); ++i) {
-    ret.emplace_back(offset_multiplier_constrain(x[i], mu_ref, sigma[i]));
-  }
-  return ret;
-}
-
-/**
- * Overload for array of x and sigma and non-array mu with lp
- */
-template <typename T, typename M, typename S,
-          require_not_std_vector_t<M>* = nullptr>
-inline auto offset_multiplier_constrain(const std::vector<T>& x, const M& mu,
-                                        const std::vector<S>& sigma,
-                                        return_type_t<T, M, S>& lp) {
-  check_matching_dims("offset_multiplier_constrain", "x", x, "sigma", sigma);
-  std::vector<plain_type_t<decltype(
-      offset_multiplier_constrain(x[0], mu, sigma[0], lp))>>
-      ret;
-  ret.reserve(x.size());
-  const auto& mu_ref = to_ref(mu);
-  for (size_t i = 0; i < x.size(); ++i) {
-    ret.emplace_back(offset_multiplier_constrain(x[i], mu_ref, sigma[i], lp));
-  }
-  return ret;
-}
-
-/**
- * Overload for array of x and mu and non-array sigma
- */
-template <typename T, typename M, typename S,
-          require_not_std_vector_t<S>* = nullptr>
-inline auto offset_multiplier_constrain(const std::vector<T>& x,
-                                        const std::vector<M>& mu,
-                                        const S& sigma) {
-  check_matching_dims("offset_multiplier_constrain", "x", x, "mu", mu);
-  std::vector<
-      plain_type_t<decltype(offset_multiplier_constrain(x[0], mu[0], sigma))>>
-      ret;
-  ret.reserve(x.size());
-  const auto& sigma_ref = to_ref(sigma);
-  for (size_t i = 0; i < x.size(); ++i) {
-    ret.emplace_back(offset_multiplier_constrain(x[i], mu[i], sigma_ref));
-  }
-  return ret;
-}
-
-/**
- * Overload for array of x and mu and non-array sigma with lp
- */
-template <typename T, typename M, typename S,
-          require_not_std_vector_t<S>* = nullptr>
-inline auto offset_multiplier_constrain(const std::vector<T>& x,
-                                        const std::vector<M>& mu,
-                                        const S& sigma,
-                                        return_type_t<T, M, S>& lp) {
-  check_matching_dims("offset_multiplier_constrain", "x", x, "mu", mu);
-  std::vector<plain_type_t<decltype(
-      offset_multiplier_constrain(x[0], mu[0], sigma, lp))>>
-      ret;
-  ret.reserve(x.size());
-  const auto& sigma_ref = to_ref(sigma);
-  for (size_t i = 0; i < x.size(); ++i) {
-    ret.emplace_back(offset_multiplier_constrain(x[i], mu[i], sigma_ref, lp));
-  }
-  return ret;
-}
-
-/**
- * Overload for array of x, mu, and sigma
- */
-template <typename T, typename M, typename S>
-inline auto offset_multiplier_constrain(const std::vector<T>& x,
-                                        const std::vector<M>& mu,
-                                        const std::vector<S>& sigma) {
-  check_matching_dims("offset_multiplier_constrain", "x", x, "mu", mu);
-  check_matching_dims("offset_multiplier_constrain", "x", x, "sigma", sigma);
-  std::vector<plain_type_t<decltype(
-      offset_multiplier_constrain(x[0], mu[0], sigma[0]))>>
-      ret;
-  ret.reserve(x.size());
-  for (size_t i = 0; i < x.size(); ++i) {
-    ret.emplace_back(offset_multiplier_constrain(x[i], mu[i], sigma[i]));
-  }
-  return ret;
-}
-
-/**
- * Overload for array of x, mu, and sigma with lp
- */
 template <typename T, typename M, typename S>
-inline auto offset_multiplier_constrain(const std::vector<T>& x,
-                                        const std::vector<M>& mu,
-                                        const std::vector<S>& sigma,
-                                        return_type_t<T, M, S>& lp) {
-  check_matching_dims("offset_multiplier_constrain", "x", x, "mu", mu);
-  check_matching_dims("offset_multiplier_constrain", "x", x, "sigma", sigma);
-  std::vector<plain_type_t<decltype(
-      offset_multiplier_constrain(x[0], mu[0], sigma[0], lp))>>
-      ret;
-  ret.reserve(x.size());
-  for (size_t i = 0; i < x.size(); ++i) {
-    ret.emplace_back(offset_multiplier_constrain(x[i], mu[i], sigma[i], lp));
-  }
-  return ret;
-}
-
-/**
- * Return the linearly transformed value for the specified unconstrained input
- * and specified offset and multiplier. If the `Jacobian` parameter is `true`,
- * the log density accumulator is incremented with the log absolute Jacobian
- * determinant of the transform.  All of the transforms are specified with their
- * Jacobians in the *Stan Reference Manual* chapter Constraint Transforms.
- *
- * @tparam Jacobian if `true`, increment log density accumulator with log
- * absolute Jacobian determinant of constraining transform
- * @tparam T A type inheriting from `Eigen::EigenBase`, a `var_value` with inner
- * type inheriting from `Eigen::EigenBase`, a standard vector, or a scalar
- * @tparam M A type inheriting from `Eigen::EigenBase`, a `var_value` with inner
- * type inheriting from `Eigen::EigenBase`, a standard vector, or a scalar
- * @tparam S A type inheriting from `Eigen::EigenBase`, a `var_value` with inner
- * type inheriting from `Eigen::EigenBase`, a standard vector, or a scalar
- * @param[in] x Unconstrained scalar input
- * @param[in] mu offset of constrained output
- * @param[in] sigma multiplier of constrained output
- * @param[in, out] lp log density accumulator
- * @return linear transformed value corresponding to inputs
- * @throw std::domain_error if sigma <= 0
- * @throw std::domain_error if mu is not finite
- */
-template <bool Jacobian, typename T, typename M, typename S>
-inline auto offset_multiplier_constrain(const T& x, const M& mu, const S& sigma,
-                                        return_type_t<T, M, S>& lp) {
-  if (Jacobian) {
-    return offset_multiplier_constrain(x, mu, sigma, lp);
-  } else {
-    return offset_multiplier_constrain(x, mu, sigma);
+inline return_type_t<T, M, S> offset_multiplier_constrain(const T& x,
+                                                          const M& mu,
+                                                          const S& sigma,
+                                                          T& lp) {
+  using std::log;
+  check_finite("offset_multiplier_constrain", "offset", mu);
+  if (sigma == 1) {
+    if (mu == 0) {
+      return identity_constrain(x);
+    }
+    return mu + x;
   }
+  check_positive_finite("offset_multiplier_constrain", "multiplier", sigma);
+  lp += multiply_log(math::size(x), sigma);
+  return fma(sigma, x, mu);
 }
 
 }  // namespace math

stan/math/prim/prob/bernoulli_lpmf.hpp

@@ -42,8 +42,7 @@ return_type_t<T_prob> bernoulli_lpmf(const T_n& n, const T_prob& theta) {
   const T_n_ref n_ref = to_ref(n);
   const T_theta_ref theta_ref = to_ref(theta);
   check_bounded(function, "n", n_ref, 0, 1);
-  check_bounded(function, "Probability parameter", value_of(theta_ref), 0.0,
-                1.0);
+  check_bounded(function, "Probability parameter", theta_ref, 0.0, 1.0);
 
   if (size_zero(n, theta)) {
     return 0.0;
@@ -84,8 +83,8 @@ return_type_t<T_prob> bernoulli_lpmf(const T_n& n, const T_prob& theta) {
       logp += (N - sum) * log1m_theta;
 
       if (!is_constant_all<T_prob>::value) {
-        ops_partials.edge1_.partials_[0] += sum * inv(theta_dbl);
-        ops_partials.edge1_.partials_[0] += (N - sum) * inv(theta_dbl - 1);
+        ops_partials.edge1_.partials_[0] += sum / theta_dbl;
+        ops_partials.edge1_.partials_[0] += (N - sum) / (theta_dbl - 1);
       }
     }
   } else {

stan/math/prim/prob/beta_proportion_lpdf.hpp

@@ -5,7 +5,6 @@
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/as_column_vector_or_scalar.hpp>
 #include <stan/math/prim/fun/as_array_or_scalar.hpp>
-#include <stan/math/prim/fun/as_value_column_array_or_scalar.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <stan/math/prim/fun/digamma.hpp>
 #include <stan/math/prim/fun/lgamma.hpp>
@@ -52,6 +51,8 @@ return_type_t<T_y, T_loc, T_prec> beta_proportion_lpdf(const T_y& y,
                                                        const T_loc& mu,
                                                        const T_prec& kappa) {
   using T_partials_return = partials_return_t<T_y, T_loc, T_prec>;
+  using T_partials_return_kappa = return_type_t<T_prec>;
+  using T_partials_array = Eigen::Array<T_partials_return, Eigen::Dynamic, 1>;
   using std::log;
   using T_y_ref = ref_type_if_t<!is_constant<T_y>::value, T_y>;
   using T_mu_ref = ref_type_if_t<!is_constant<T_loc>::value, T_loc>;
@@ -67,14 +68,23 @@ return_type_t<T_y, T_loc, T_prec> beta_proportion_lpdf(const T_y& y,
   T_mu_ref mu_ref = mu;
   T_kappa_ref kappa_ref = kappa;
 
-  decltype(auto) y_val = to_ref(as_value_column_array_or_scalar(y_ref));
-  decltype(auto) mu_val = to_ref(as_value_column_array_or_scalar(mu_ref));
-  decltype(auto) kappa_val = to_ref(as_value_column_array_or_scalar(kappa_ref));
+  const auto& y_col = as_column_vector_or_scalar(y_ref);
+  const auto& mu_col = as_column_vector_or_scalar(mu_ref);
+  const auto& kappa_col = as_column_vector_or_scalar(kappa_ref);
+
+  const auto& y_arr = as_array_or_scalar(y_col);
+  const auto& mu_arr = as_array_or_scalar(mu_col);
+  const auto& kappa_arr
+      = promote_scalar<T_partials_return_kappa>(as_array_or_scalar(kappa_col));
+
+  ref_type_t<decltype(value_of(y_arr))> y_val = value_of(y_arr);
+  ref_type_t<decltype(value_of(mu_arr))> mu_val = value_of(mu_arr);
+  ref_type_t<decltype(value_of(kappa_arr))> kappa_val = value_of(kappa_arr);
 
   check_positive(function, "Location parameter", mu_val);
   check_less(function, "Location parameter", mu_val, 1.0);
   check_positive_finite(function, "Precision parameter", kappa_val);
-  check_bounded(function, "Random variable", value_of(y_val), 0, 1);
+  check_bounded(function, "Random variable", y_val, 0, 1);
 
   if (!include_summand<propto, T_y, T_loc, T_prec>::value) {
     return 0;