combine definitions for vector of ints and single int for several of the unary functions

Author: SteveBronder

stan/math/rev/fun/bessel_first_kind.hpp

@@ -18,25 +18,14 @@ inline var bessel_first_kind(int v, const var& a) {
                            });
 }
 
-template <typename T, require_eigen_t<T>* = nullptr>
-inline auto bessel_first_kind(int v, const var_value<T>& a) {
+template <typename T1, typename T2,
+          require_st_integral<T1>* = nullptr,
+          require_eigen_t<T2>* = nullptr>
+inline auto bessel_first_kind(const T1& v, const var_value<T2>& a) {
   auto ret_val = bessel_first_kind(v, a.val()).array().eval();
-  auto precomp_bessel = to_arena(v * ret_val / a.val().array()
-                                 - bessel_first_kind(v + 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;
-      });
-}
-
-template <typename T, require_eigen_t<T>* = nullptr>
-inline auto bessel_first_kind(const std::vector<int>& v,
-                              const var_value<T>& a) {
-  auto ret_val = bessel_first_kind(v, a.val()).array().eval();
-  Eigen::Map<const Eigen::Array<int, -1, 1>> v_map(v.data(), v.size());
-  auto precomp_bessel
-      = to_arena(v_map.template cast<double>() * ret_val / a.val().array()
-                 - bessel_first_kind(v_map + 1, a.val().array()));
+  auto v_map = as_array_or_scalar(v);
+  auto precomp_bessel = to_arena(v_map * ret_val / a.val().array()
+                                 - bessel_first_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;

stan/math/rev/fun/bessel_second_kind.hpp

@@ -17,25 +17,14 @@ inline var bessel_second_kind(int v, const var& a) {
   });
 }
 
-template <typename T, require_eigen_t<T>* = nullptr>
-inline auto bessel_second_kind(int v, const var_value<T>& a) {
+template <typename T1, typename T2,
+          require_st_integral<T1>* = nullptr,
+          require_eigen_t<T2>* = nullptr>
+inline auto bessel_second_kind(const T1& v, const var_value<T2>& a) {
   auto ret_val = bessel_second_kind(v, a.val()).array().eval();
-  auto precomp_bessel = to_arena(v * ret_val / a.val().array()
-                                 - bessel_second_kind(v + 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;
-      });
-}
-
-template <typename T, require_eigen_t<T>* = nullptr>
-inline auto bessel_second_kind(const std::vector<int>& v,
-                               const var_value<T>& a) {
-  auto ret_val = bessel_second_kind(v, a.val()).array().eval();
-  Eigen::Map<const Eigen::Array<int, -1, 1>> v_map(v.data(), v.size());
-  auto precomp_bessel
-      = to_arena(v_map.template cast<double>() * ret_val / a.val().array()
-                 - bessel_second_kind(v_map + 1, a.val().array()));
+  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;

stan/math/rev/fun/binary_log_loss.hpp

@@ -85,17 +85,6 @@ inline auto binary_log_loss(const std::vector<int>& y,
            / (arena_y == 0)
                  .select((1.0 - y_hat.val().array()), -y_hat.val().array());
   });
-  /*
-  if (y == 0) {
-    return make_callback_var(-log1p(-y_hat.val()), [y_hat](auto& vi) mutable {
-      y_hat.adj().array() += vi.adj().array() / (1.0 - y_hat.val().array());
-    });
-  } else {
-    return make_callback_var(-std::log(y_hat.val()), [y_hat](auto& vi) mutable {
-      y_hat.adj().array() -= vi.adj().array() / y_hat.val().array();
-    });
-  }
-  */
 }
 
 }  // namespace math

stan/math/rev/fun/exp2.hpp

@@ -3,6 +3,7 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/prim/fun/exp2.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <cmath>
 
@@ -43,8 +44,7 @@ inline var exp2(const var& a) {
 
 template <typename T, require_eigen_t<T>* = nullptr>
 inline auto exp2(const var_value<T>& a) {
-  return make_callback_var(
-      a.val().unaryExpr([](auto&& x) { return std::exp2(x); }),
+  return make_callback_var(exp2(a.val()),
       [a](auto& vi) mutable {
         a.adj().array() += vi.adj().array() * vi.val().array() * LOG_TWO;
       });

stan/math/rev/fun/expm1.hpp

@@ -41,9 +41,9 @@ inline var expm1(const var& a) {
   });
 }
 
-template <typename T, require_matrix_t<T>* = nullptr>
+template <typename T, require_eigen_t<T>* = nullptr>
 inline auto expm1(const var_value<T>& a) {
-  return make_callback_var(expm1(a.val()).eval(), [a](auto& vi) mutable {
+  return make_callback_var(expm1(a.val()), [a](auto& vi) mutable {
     a.adj().array() += vi.adj().array() * (vi.val().array() + 1.0);
   });
 }

stan/math/rev/fun/falling_factorial.hpp

@@ -17,27 +17,16 @@ inline var falling_factorial(const var& a, int b) {
                            });
 }
 
-template <typename T, require_eigen_t<T>* = nullptr>
-inline auto falling_factorial(const var_value<T>& a, int b) {
-  auto digamma_ab = to_arena(digamma(a.val().array() + 1)
-                             - digamma(a.val().array() - b + 1));
-  return make_callback_var(
-      falling_factorial(a.val(), b), [a, digamma_ab](auto& vi) mutable {
-        a.adj().array() += vi.adj().array() * vi.val().array() * digamma_ab;
-      });
-}
-
-template <typename T, typename StdVec, require_eigen_t<T>* = nullptr,
-          require_vector_like_vt<std::is_integral, StdVec>* = nullptr>
-inline auto falling_factorial(const var_value<T>& a, const StdVec& b) {
-  Eigen::Array<int, -1, 1> b_map
-      = Eigen::Map<const Eigen::Array<int, -1, 1>>(b.data(), b.size());
+template <typename T1, typename T2, require_eigen_t<T1>* = nullptr,
+          require_st_integral<T2>* = nullptr>
+inline auto falling_factorial(const var_value<T1>& a, const T2& b) {
+  auto b_map = as_array_or_scalar(b);
   auto digamma_ab = to_arena(digamma(a.val().array() + 1)
                              - digamma(a.val().array() - b_map + 1));
-  return make_callback_var(
-      falling_factorial(a.val(), b), [a, digamma_ab](auto& vi) mutable {
-        a.adj().array() += vi.adj().array() * vi.val().array() * digamma_ab;
-      });
+ return make_callback_var(
+     falling_factorial(a.val(), b), [a, digamma_ab](auto& vi) mutable {
+       a.adj().array() += vi.adj().array() * vi.val().array() * digamma_ab;
+     });
 }
 
 }  // namespace math