Allow Eigen to use the apply_scalar_unary framework

Author: SteveBronder

stan/math/prim/fun/inv_logit.hpp

@@ -68,38 +68,41 @@ inline double inv_logit(double a) {
  */
 struct inv_logit_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return inv_logit(x);
+  static inline auto fun(T&& x) {
+    return inv_logit(std::forward<T>(x));
   }
 };
 
 /**
- * Vectorized version of inv_logit() for Eigen types.
+ * Vectorized version of inv_logit() for std::vector's containing ad types.
  *
- * @tparam T A type inheriting from `Eigen::DenseBase` that does not have a
- * `var` scalar type.
- * @param x Eigen expression
+ * @tparam T type of std::vector
+ * @param x std::vector
  * @return Inverse logit applied to each value in x.
  */
-template <typename T, require_eigen_t<T>* = nullptr,
-          require_not_vt_var<T>* = nullptr>
-inline auto inv_logit(T&& x) {
-  return std::forward<T>(x).array().logistic().matrix();
+template <typename Container, require_ad_container_t<Container>* = nullptr,
+  require_all_not_nonscalar_prim_or_rev_kernel_expression_t<Container>* = nullptr,
+  require_not_rev_matrix_t<Container>* = nullptr>
+inline auto inv_logit(Container&& x) {
+  return apply_scalar_unary<inv_logit_fun, Container>::apply(std::forward<Container>(x));
 }
 
 /**
- * Vectorized version of inv_logit() for std::vector.
+ * Vectorized version of inv_logit() for Eigen types.
  *
- * @tparam T type of std::vector
- * @param x std::vector
+ * @tparam T A type of either `std::vector` whose inner type inherits from `Eigen::DenseBase` or a 
+ *  type that directly inherits from `Eigen::DenseBase`. The inner scalar type must not have a
+ * `var` scalar type.
+ * @param x Eigen expression
  * @return Inverse logit applied to each value in x.
  */
-template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto inv_logit(T&& x) {
-  return apply_scalar_unary<inv_logit_fun, std::decay_t<T>>::apply(
-      std::forward<T>(x));
+template <typename Container,
+          require_container_bt<std::is_arithmetic, Container>* = nullptr,
+  require_all_not_nonscalar_prim_or_rev_kernel_expression_t<Container>* = nullptr>
+inline auto inv_logit(Container&& x) {
+  return apply_vector_unary<Container>::apply(
+      std::forward<Container>(x), [](const auto& v) { return v.array().logistic(); });
 }
-
 }  // namespace math
 }  // namespace stan
 

stan/math/prim/functor/apply_scalar_unary.hpp

@@ -58,7 +58,7 @@ struct apply_scalar_unary<F, T, require_eigen_t<T>> {
    * @return Componentwise application of the function specified
    * by F to the specified matrix.
    */
-  static inline auto apply(const T& x) {
+  static inline auto apply(const std::decay_t<T>& x) {
     return x.unaryExpr([](auto&& x) {
       return apply_scalar_unary<F, std::decay_t<decltype(x)>>::apply(x);
     });
@@ -69,7 +69,7 @@ struct apply_scalar_unary<F, T, require_eigen_t<T>> {
    * expression template of type T.
    */
   using return_t = std::decay_t<decltype(
-      apply_scalar_unary<F, T>::apply(std::declval<T>()))>;
+      apply_scalar_unary<F, std::decay_t<T>>::apply(std::declval<T>()))>;
 };
 
 /**
@@ -83,7 +83,7 @@ struct apply_scalar_unary<F, T, require_floating_point_t<T>> {
   /**
    * The return type, double.
    */
-  using return_t = std::decay_t<decltype(F::fun(std::declval<T>()))>;
+  using return_t = std::decay_t<decltype(F::fun(std::declval<std::decay_t<T>>()))>;
 
   /**
    * Apply the function specified by F to the specified argument.
@@ -114,11 +114,11 @@ struct apply_scalar_unary<F, T, require_complex_t<T>> {
    * @param x Argument scalar.
    * @return Result of applying F to the scalar.
    */
-  static inline auto apply(const T& x) { return F::fun(x); }
+  static inline auto apply(const std::decay_t<T>& x) { return F::fun(x); }
   /**
    * The return type
    */
-  using return_t = std::decay_t<decltype(F::fun(std::declval<T>()))>;
+  using return_t = std::decay_t<decltype(F::fun(std::declval<std::decay_t<T>>()))>;
 };
 
 /**
@@ -157,13 +157,13 @@ struct apply_scalar_unary<F, T, require_integral_t<T>> {
  * @tparam T Type of element contained in standard vector.
  */
 template <typename F, typename T>
-struct apply_scalar_unary<F, std::vector<T>> {
+struct apply_scalar_unary<F, T, require_std_vector_t<T>> {
   /**
    * Return type, which is calculated recursively as a standard
    * vector of the return type of the contained type T.
    */
   using return_t = typename std::vector<
-      plain_type_t<typename apply_scalar_unary<F, T>::return_t>>;
+      plain_type_t<typename apply_scalar_unary<F, value_type_t<std::decay_t<T>>>::return_t>>;
 
   /**
    * Apply the function specified by F elementwise to the
@@ -174,10 +174,10 @@ struct apply_scalar_unary<F, std::vector<T>> {
    * @return Elementwise application of F to the elements of the
    * container.
    */
-  static inline auto apply(const std::vector<T>& x) {
+  static inline auto apply(const std::decay_t<T>& x) {
     return_t fx(x.size());
     for (size_t i = 0; i < x.size(); ++i) {
-      fx[i] = apply_scalar_unary<F, T>::apply(x[i]);
+      fx[i] = apply_scalar_unary<F, value_type_t<T>>::apply(x[i]);
     }
     return fx;
   }