Use Perfect Forwarding in all functions that use apply family of functors

stan/math/fwd/fun/inv_logit.hpp

@@ -16,10 +16,10 @@ namespace math {
  * @param x argument
  * @return inverse logit of argument
  */
-template <typename T>
-inline fvar<T> inv_logit(const fvar<T>& x) {
-  return fvar<T>(inv_logit(x.val_),
-                 x.d_ * inv_logit(x.val_) * (1 - inv_logit(x.val_)));
+template <typename T, require_fvar_t<T>* = nullptr>
+inline auto inv_logit(T&& x) {
+  return std::decay_t<T>(inv_logit(x.val_),
+                         x.d_ * inv_logit(x.val_) * (1 - inv_logit(x.val_)));
 }
 
 }  // namespace math

stan/math/fwd/functor/apply_scalar_unary.hpp

@@ -18,20 +18,23 @@ namespace math {
  * autodiff variable.
  */
 template <typename F, typename T>
-struct apply_scalar_unary<F, fvar<T> > {
+struct apply_scalar_unary<F, T, require_fvar_t<T>> {
   /**
    * Function return type, which is same as the argument type for
    * the function, <code>fvar&lt;T&gt;</code>.
    */
-  using return_t = fvar<T>;
+  using return_t = std::decay_t<T>;
 
   /**
    * Apply the function specified by F to the specified argument.
    *
    * @param x Argument variable.
    * @return Function applied to the variable.
    */
-  static inline return_t apply(const fvar<T>& x) { return F::fun(x); }
+  template <typename T2>
+  static inline auto apply(T2&& x) {
+    return F::fun(std::forward<T2>(x));
+  }
 };
 
 }  // namespace math

stan/math/opencl/prim/dirichlet_lpdf.hpp

@@ -2,6 +2,7 @@
 #define STAN_MATH_OPENCL_PRIM_DIRICHLET_LPDF_HPP
 #ifdef STAN_OPENCL
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/constants.hpp>

stan/math/prim/core/complex_base.hpp

@@ -17,6 +17,7 @@ namespace math {
 template <typename ValueType>
 class complex_base {
  public:
+  auto __rep() const { return *this; }
   /**
    * Type of real and imaginary parts
    */

stan/math/prim/fun/Phi.hpp

@@ -51,8 +51,8 @@ inline double Phi(double x) {
  */
 struct Phi_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return Phi(x);
+  static inline auto fun(T&& x) {
+    return Phi(std::forward<T>(x));
   }
 };
 
@@ -66,9 +66,9 @@ struct Phi_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr>
-inline auto Phi(const T& x) {
-  return apply_scalar_unary<Phi_fun, T>::apply(x);
+    require_container_t<T>* = nullptr, require_not_var_matrix_t<T>* = nullptr>
+inline auto Phi(T&& x) {
+  return apply_scalar_unary<Phi_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math

stan/math/prim/fun/Phi_approx.hpp

@@ -47,8 +47,8 @@ struct Phi_approx_fun {
    * @return approximate value of Phi applied to argument
    */
   template <typename T>
-  static inline auto fun(const T& x) {
-    return Phi_approx(x);
+  static inline auto fun(T&& x) {
+    return Phi_approx(std::forward<T>(x));
   }
 };
 
@@ -65,9 +65,9 @@ struct Phi_approx_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr>
-inline auto Phi_approx(const T& x) {
-  return apply_scalar_unary<Phi_approx_fun, T>::apply(x);
+    require_container_t<T>* = nullptr, require_not_var_matrix_t<T>* = nullptr>
+inline auto Phi_approx(T&& x) {
+  return apply_scalar_unary<Phi_approx_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math

stan/math/prim/fun/abs.hpp

@@ -22,7 +22,7 @@ namespace math {
  * @return absolute value of argument
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
-inline T abs(T x) {
+inline auto abs(T&& x) {
   return std::abs(x);
 }
 
@@ -35,7 +35,7 @@ inline T abs(T x) {
  * @return absolute value of argument (a real number)
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
-inline auto abs(T x) {
+inline auto abs(T&& x) {
   return std::hypot(x.real(), x.imag());
 }
 
@@ -49,8 +49,12 @@ inline auto abs(T x) {
  */
 struct abs_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return abs(x);
+  static inline auto fun(T&& x) {
+    if constexpr (std::is_arithmetic_v<std::decay_t<T>>) {
+      return std::abs(x);
+    } else {
+      return abs(std::forward<T>(x));
+    }
   }
 };
 
@@ -63,8 +67,9 @@ struct abs_fun {
  * @return Absolute value of each variable in the container.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto abs(const Container& x) {
-  return apply_scalar_unary<abs_fun, Container>::apply(x);
+inline auto abs(Container&& x) {
+  return apply_scalar_unary<abs_fun, Container>::apply(
+      std::forward<Container>(x));
 }
 
 /**
@@ -77,9 +82,10 @@ inline auto abs(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto abs(const Container& x) {
+inline auto abs(Container&& x) {
   return apply_vector_unary<Container>::apply(
-      x, [&](const auto& v) { return v.array().abs(); });
+      std::forward<Container>(x),
+      [&](const auto& v) { return v.array().abs(); });
 }
 
 namespace internal {

stan/math/prim/fun/acos.hpp

@@ -26,7 +26,7 @@ namespace math {
  * @return arc cosine of the argument
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
-inline auto acos(const T x) {
+inline auto acos(T&& x) {
   return std::acos(x);
 }
 
@@ -38,7 +38,7 @@ inline auto acos(const T x) {
  * @return arc cosine of the argument
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
-inline auto acos(const T x) {
+inline auto acos(T&& x) {
   return std::acos(x);
 }
 
@@ -51,8 +51,12 @@ inline auto acos(const T x) {
  */
 struct acos_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return acos(x);
+  static inline auto fun(T&& x) {
+    if constexpr (std::is_arithmetic_v<std::decay_t<T>>) {
+      return std::acos(x);
+    } else {
+      return acos(std::forward<T>(x));
+    }
   }
 };
 
@@ -65,8 +69,9 @@ struct acos_fun {
  * @return Arc cosine of each variable in the container, in radians.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto acos(const Container& x) {
-  return apply_scalar_unary<acos_fun, Container>::apply(x);
+inline auto acos(Container&& x) {
+  return apply_scalar_unary<acos_fun, Container>::apply(
+      std::forward<Container>(x));
 }
 
 /**
@@ -79,9 +84,9 @@ inline auto acos(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto acos(const Container& x) {
+inline auto acos(Container&& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().acos(); });
+      std::forward<Container>(x), [](auto&& v) { return v.array().acos(); });
 }
 
 namespace internal {

stan/math/prim/fun/acosh.hpp

@@ -24,7 +24,7 @@ namespace math {
  * @throw std::domain_error If argument is less than 1.
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
-inline double acosh(const T x) {
+inline double acosh(T&& x) {
   if (is_nan(x)) {
     return x;
   } else {
@@ -46,7 +46,7 @@ inline double acosh(const T x) {
  * @throw std::domain_error If argument is less than 1.
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
-inline auto acosh(const T x) {
+inline auto acosh(T&& x) {
   return std::acosh(x);
 }
 
@@ -62,8 +62,8 @@ struct acosh_fun {
    * @return Inverse hyperbolic cosine of the argument.
    */
   template <typename T>
-  static inline auto fun(const T& x) {
-    return acosh(x);
+  static inline auto fun(T&& x) {
+    return acosh(std::forward<T>(x));
   }
 };
 
@@ -78,8 +78,8 @@ struct acosh_fun {
  * @return Elementwise acosh of members of container.
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
-inline auto acosh(const T& x) {
-  return apply_scalar_unary<acosh_fun, T>::apply(x);
+inline auto acosh(T&& x) {
+  return apply_scalar_unary<acosh_fun, T>::apply(std::forward<T>(x));
 }
 
 /**
@@ -94,8 +94,9 @@ inline auto acosh(const T& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto acosh(const Container& x) {
-  return apply_scalar_unary<acosh_fun, Container>::apply(x);
+inline auto acosh(Container&& x) {
+  return apply_scalar_unary<acosh_fun, Container>::apply(
+      std::forward<Container>(x));
 }
 
 namespace internal {

stan/math/prim/fun/asin.hpp

@@ -24,7 +24,7 @@ namespace math {
  * @return arc sine of the argument
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
-inline auto asin(const T x) {
+inline auto asin(T&& x) {
   return std::asin(x);
 }
 
@@ -36,7 +36,7 @@ inline auto asin(const T x) {
  * @return arc sine of the argument
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
-inline auto asin(const T x) {
+inline auto asin(T&& x) {
   return std::asin(x);
 }
 
@@ -49,8 +49,12 @@ inline auto asin(const T x) {
  */
 struct asin_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return asin(x);
+  static inline auto fun(T&& x) {
+    if constexpr (std::is_arithmetic_v<std::decay_t<T>>) {
+      return std::asin(x);
+    } else {
+      return asin(std::forward<T>(x));
+    }
   }
 };
 
@@ -63,8 +67,9 @@ struct asin_fun {
  * @return Arcsine of each variable in the container, in radians.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto asin(const Container& x) {
-  return apply_scalar_unary<asin_fun, Container>::apply(x);
+inline auto asin(Container&& x) {
+  return apply_scalar_unary<asin_fun, Container>::apply(
+      std::forward<Container>(x));
 }
 
 /**
@@ -77,9 +82,9 @@ inline auto asin(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto asin(const Container& x) {
+inline auto asin(Container&& x) {
   return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().asin(); });
+      std::forward<Container>(x), [](auto&& v) { return v.array().asin(); });
 }
 
 namespace internal {

stan/math/prim/fun/asinh.hpp

@@ -27,7 +27,7 @@ namespace math {
  * @return hyperbolic arc sine of the argument
  */
 template <typename T, require_arithmetic_t<T>* = nullptr>
-inline auto asinh(const T x) {
+inline auto asinh(T&& x) {
   return std::asinh(x);
 }
 
@@ -39,7 +39,7 @@ inline auto asinh(const T x) {
  * @return hyperbolic arc sine of the argument
  */
 template <typename T, require_complex_bt<std::is_arithmetic, T>* = nullptr>
-inline auto asinh(const T x) {
+inline auto asinh(T&& x) {
   return std::asinh(x);
 }
 
@@ -52,8 +52,12 @@ inline auto asinh(const T x) {
  */
 struct asinh_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return asinh(x);
+  static inline auto fun(T&& x) {
+    if constexpr (std::is_arithmetic_v<std::decay_t<T>>) {
+      return std::asinh(x);
+    } else {
+      return asinh(std::forward<T>(x));
+    }
   }
 };
 
@@ -66,8 +70,8 @@ struct asinh_fun {
  * @return Inverse hyperbolic sine of each value in the container.
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
-inline auto asinh(const T& x) {
-  return apply_scalar_unary<asinh_fun, T>::apply(x);
+inline auto asinh(T&& x) {
+  return apply_scalar_unary<asinh_fun, T>::apply(std::forward<T>(x));
 }
 
 /**
@@ -80,8 +84,9 @@ inline auto asinh(const T& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto asinh(const Container& x) {
-  return apply_scalar_unary<asinh_fun, Container>::apply(x);
+inline auto asinh(Container&& x) {
+  return apply_scalar_unary<asinh_fun, Container>::apply(
+      std::forward<Container>(x));
 }
 
 namespace internal {