use pf on signatures for reverse mode bessel_second_kind

Author: SteveBronder

stan/math/prim/fun/bessel_second_kind.hpp

@@ -53,7 +53,7 @@ inline T2 bessel_second_kind(int v, const T2 z) {
  * @return Bessel second kind function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
-          require_not_var_t<T2>* = nullptr>
+  require_not_var_matrix_t<T2>* = nullptr>
 inline auto bessel_second_kind(T1&& a, T2&& b) {
   return apply_scalar_binary(
       [](auto&& c, auto&& d) {

stan/math/rev/fun/bessel_second_kind.hpp

@@ -8,27 +8,34 @@
 namespace stan {
 namespace math {
 
+template <typename T1, typename T2, require_integral_t<T1>* = nullptr,
+          require_var_t<T2>* = nullptr, 
+          require_stan_scalar_t<T2>* = nullptr>
+inline var bessel_second_kind(T1&& v, T2&& a) {
+  double ret_val = bessel_second_kind(v, a.val());
+  auto precomp_bessel
+      = v * ret_val / a.val() - bessel_second_kind(v + 1, a.val());
+  return make_callback_var(ret_val, [precomp_bessel, a](auto& vi) mutable {
+    a.adj() += vi.adj() * precomp_bessel;
+  });
+}
+
+/**
+ * Overload with `var_value<Matrix>` for `int`, `std::vector<int>`, and
+ * `std::vector<std::vector<int>>`
+ */
 template <typename T1, typename T2, require_st_integral<T1>* = nullptr,
-          require_var_t<T2>* = nullptr>
+          require_var_matrix_t<T2>* = nullptr>
 inline auto bessel_second_kind(T1&& v, T2&& a) {
-  if constexpr (is_stan_scalar_v<T2>) {
-    double ret_val = bessel_second_kind(v, a.val());
-    auto precomp_bessel
-        = v * ret_val / a.val() - bessel_second_kind(v + 1, a.val());
-    return make_callback_var(ret_val, [precomp_bessel, a](auto& vi) mutable {
-      a.adj() += vi.adj() * precomp_bessel;
-    });
-  } else {
-    auto ret_val = bessel_second_kind(v, a.val()).array().eval();
-    auto v_map = as_array_or_scalar(v);
-    auto precomp_bessel
-        = to_arena(v_map * ret_val / a.val().array()
-                   - bessel_second_kind(v_map + 1, a.val().array()));
-    return make_callback_var(
-        ret_val.matrix(), [precomp_bessel, a](const auto& vi) mutable {
-          a.adj().array() += vi.adj().array() * precomp_bessel;
-        });
-  }
+  auto ret_val = bessel_second_kind(v, a.val()).array().eval();
+  auto v_map = as_array_or_scalar(v);
+  auto precomp_bessel
+      = to_arena(v_map * ret_val / a.val().array()
+                 - bessel_second_kind(v_map + 1, a.val().array()));
+  return make_callback_var(
+      ret_val.matrix(), [precomp_bessel, a](const auto& vi) mutable {
+        a.adj().array() += vi.adj().array() * precomp_bessel;
+      });
 }
 
 }  // namespace math

test/unit/math/mix/fun/bessel_second_kind_test.cpp

@@ -3,7 +3,7 @@
 
 TEST(mathMixScalFun, besselSecondKind) {
   // bind integer arg because can't autodiff through
-  auto f = [](const int x1) {
+  auto f = [](const auto& x1) {
     return
         [=](const auto& x2) { return stan::math::bessel_second_kind(x1, x2); };
   };
@@ -13,6 +13,13 @@ TEST(mathMixScalFun, besselSecondKind) {
   stan::test::expect_ad(f(1), 3.0);
   stan::test::expect_ad(f(1), std::numeric_limits<double>::quiet_NaN());
   stan::test::expect_ad(f(2), 2.79);
+  std::vector<int> std_in1{3, 1};
+  stan::test::expect_ad(f(std_in1), 4.0);
+  stan::test::expect_ad(f(std_in1), std::numeric_limits<double>::quiet_NaN());
+  stan::test::expect_ad(f(std_in1), -3.0);
+  stan::test::expect_ad(f(std_in1), 3.0);
+  stan::test::expect_ad(f(std_in1), std::numeric_limits<double>::quiet_NaN());
+  stan::test::expect_ad(f(std_in1), 2.79);
 }
 
 TEST(mathMixScalFun, besselSecondKind_vec) {
@@ -31,6 +38,7 @@ TEST(mathMixScalFun, besselSecondKind_vec) {
   Eigen::MatrixXd mat_in2 = in2.replicate(1, 2);
   stan::test::expect_ad_vectorized_binary(f, std_std_in1, mat_in2);
   stan::test::expect_ad_matvar(f, std_std_in1, mat_in2);
+
 }
 
 TEST(mathMixScalFun, besselSecondKind_matvec) {