Merge remote-tracking branch 'origin/5.0-breaking-changes' into move-constraint-transforms-to-separate-folder

Author: SteveBronder

doxygen/contributor_help_pages/distribution_tests.md

@@ -28,7 +28,7 @@ Here, I'm just going to describe the steps that are taken to run the tests. Deta
 
 1. `make generate-tests` is called.
     1. This first builds the `test/prob/generate_tests` executable from `test/prob/generate_tests.cpp`.
-    2. For each test file inside `test/prob/*/*`, it will call the executable with the test file as the first argument and the number of template instantiations per file within the second argument. For example, for testing the `bernoulli_log()` function, make will call: `test/prob/generate_tests test/prob/bernoulli/bernoulli_test.hpp 100`
+    2. For each test file inside `test/prob/*/*`, it will call the executable with the test file as the first argument and the number of template instantiations per file within the second argument. For example, for testing the `bernoulli_lpmf()` function, make will call: `test/prob/generate_tests test/prob/bernoulli/bernoulli_test.hpp 100`
     The call to the executable will generate 5 different test files, all within the `test/prob/bernoulli/` folder:
         - bernoulli\_00000\_generated\_fd\_test.cpp
         - bernoulli\_00000\_generated\_ffd\_test.cpp

doxygen/contributor_help_pages/require_meta.md

@@ -41,6 +41,7 @@
 #include <stan/math/fwd/fun/gamma_p.hpp>
 #include <stan/math/fwd/fun/gamma_q.hpp>
 #include <stan/math/fwd/fun/grad_inc_beta.hpp>
+#include <stan/math/fwd/fun/hypergeometric_1F0.hpp>
 #include <stan/math/fwd/fun/hypergeometric_2F1.hpp>
 #include <stan/math/fwd/fun/hypergeometric_pFq.hpp>
 #include <stan/math/fwd/fun/hypot.hpp>

stan/math/fwd/fun.hpp

@@ -0,0 +1,46 @@
+#ifndef STAN_MATH_FWD_FUN_HYPERGEOMETRIC_1F0_HPP
+#define STAN_MATH_FWD_FUN_HYPERGEOMETRIC_1F0_HPP
+
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/fun/hypergeometric_1F0.hpp>
+#include <stan/math/fwd/core.hpp>
+
+namespace stan {
+namespace math {
+
+/**
+ * Returns the Hypergeometric 1F0 function applied to the
+ * input arguments:
+ * \f$ _1F_0(a;;z) = \sum_{k=1}^{\infty}\frac{\left(a\right)_kz^k}{k!}\f$
+ *
+ * \f$ \frac{\partial _1F_0\left(a;;z\right)}{\partial a} =
+ *    -\left(1-z\right)^{-a}\log\left(1 - z\right) \f$
+ *
+ * \f$ \frac{\partial _1F_0\left(a;;z\right)}{\partial z} =
+ *    a\left(1-z\right)^{-a-1} \f$
+ *
+ * @tparam Ta Fvar or arithmetic type of 'a' argument
+ * @tparam Tz Fvar or arithmetic type of 'z' argument
+ * @param[in] a Scalar 'a' argument
+ * @param[in] z Scalar z argument
+ * @return Hypergeometric 1F0 function
+ */
+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>
+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 (!is_constant_all<Ta>::value) {
+    rtn.d_ += forward_as<FvarT>(a).d() * -rtn.val() * log1m(z_val);
+  }
+  if (!is_constant_all<Tz>::value) {
+    rtn.d_ += forward_as<FvarT>(z).d() * rtn.val() * a_val * inv(1 - z_val);
+  }
+  return rtn;
+}
+
+}  // namespace math
+}  // namespace stan
+#endif

stan/math/fwd/fun/hypergeometric_1F0.hpp

@@ -22,32 +22,42 @@ namespace math {
  * @return Generalized hypergeometric function
  */
 template <typename Ta, typename Tb, typename Tz,
-          require_all_matrix_t<Ta, Tb>* = nullptr,
-          require_return_type_t<is_fvar, Ta, Tb, Tz>* = nullptr>
-inline return_type_t<Ta, Tb, Tz> hypergeometric_pFq(const Ta& a, const Tb& b,
-                                                    const Tz& z) {
-  using fvar_t = return_type_t<Ta, Tb, Tz>;
-  ref_type_t<Ta> a_ref = a;
-  ref_type_t<Tb> b_ref = b;
-  auto grad_tuple = grad_pFq(a_ref, b_ref, z);
-
-  typename fvar_t::Scalar grad = 0;
-
-  if (!is_constant<Ta>::value) {
-    grad += dot_product(forward_as<promote_scalar_t<fvar_t, Ta>>(a_ref).d(),
-                        std::get<0>(grad_tuple));
+          typename FvarT = return_type_t<Ta, Tb, Tz>,
+          bool grad_a = !is_constant<Ta>::value,
+          bool grad_b = !is_constant<Tb>::value,
+          bool grad_z = !is_constant<Tz>::value,
+          require_all_vector_t<Ta, Tb>* = nullptr,
+          require_fvar_t<FvarT>* = nullptr>
+inline FvarT hypergeometric_pFq(const Ta& a, const Tb& b, const Tz& z) {
+  using PartialsT = partials_type_t<FvarT>;
+  using ARefT = ref_type_t<Ta>;
+  using BRefT = ref_type_t<Tb>;
+
+  ARefT a_ref = a;
+  BRefT b_ref = b;
+  auto&& a_val = value_of(a_ref);
+  auto&& b_val = value_of(b_ref);
+  auto&& z_val = value_of(z);
+  PartialsT pfq_val = hypergeometric_pFq(a_val, b_val, z_val);
+  auto grad_tuple
+      = grad_pFq<grad_a, grad_b, grad_z>(pfq_val, a_val, b_val, z_val);
+
+  FvarT rtn = FvarT(pfq_val, 0.0);
+
+  if (grad_a) {
+    rtn.d_ += dot_product(forward_as<promote_scalar_t<FvarT, ARefT>>(a_ref).d(),
+                          std::get<0>(grad_tuple));
   }
-  if (!is_constant<Tb>::value) {
-    grad += dot_product(forward_as<promote_scalar_t<fvar_t, Tb>>(b_ref).d(),
-                        std::get<1>(grad_tuple));
+  if (grad_b) {
+    rtn.d_ += dot_product(forward_as<promote_scalar_t<FvarT, BRefT>>(b_ref).d(),
+                          std::get<1>(grad_tuple));
   }
-  if (!is_constant<Tz>::value) {
-    grad += forward_as<promote_scalar_t<fvar_t, Tz>>(z).d_
-            * std::get<2>(grad_tuple);
+  if (grad_z) {
+    rtn.d_ += forward_as<promote_scalar_t<FvarT, Tz>>(z).d_
+              * std::get<2>(grad_tuple);
   }
 
-  return fvar_t(
-      hypergeometric_pFq(value_of(a_ref), value_of(b_ref), value_of(z)), grad);
+  return rtn;
 }
 
 }  // namespace math

stan/math/fwd/fun/hypergeometric_pFq.hpp

@@ -122,6 +122,7 @@
 #include <stan/math/prim/fun/grad_reg_inc_gamma.hpp>
 #include <stan/math/prim/fun/grad_reg_lower_inc_gamma.hpp>
 #include <stan/math/prim/fun/head.hpp>
+#include <stan/math/prim/fun/hypergeometric_1F0.hpp>
 #include <stan/math/prim/fun/hypergeometric_2F1.hpp>
 #include <stan/math/prim/fun/hypergeometric_2F2.hpp>
 #include <stan/math/prim/fun/hypergeometric_3F2.hpp>