fix apply_scalar_unary and abs so that abs(complex<T>) return T

stan/math/mix.hpp

@@ -5,15 +5,15 @@
 #include <stan/math/mix/fun.hpp>
 #include <stan/math/mix/functor.hpp>
 
-#ifdef STAN_OPENCL
-#include <stan/math/opencl/rev.hpp>
-#endif
-
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/fun.hpp>
 #include <stan/math/fwd/functor.hpp>
 
+#ifdef STAN_OPENCL
+#include <stan/math/opencl/rev.hpp>
+#endif
+
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/fun.hpp>

stan/math/prim/fun/Phi.hpp

@@ -51,7 +51,7 @@ inline double Phi(double x) {
  */
 struct Phi_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return Phi(x);
   }
 };

stan/math/prim/fun/Phi_approx.hpp

@@ -47,7 +47,7 @@ struct Phi_approx_fun {
    * @return approximate value of Phi applied to argument
    */
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return Phi_approx(x);
   }
 };

stan/math/prim/fun/abs.hpp

@@ -49,7 +49,7 @@ inline auto abs(T x) {
  */
 struct abs_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return abs(x);
   }
 };

stan/math/prim/fun/acos.hpp

@@ -27,7 +27,7 @@ namespace math {
  */
 struct acos_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::acos;
     return acos(x);
   }

stan/math/prim/fun/acosh.hpp

@@ -68,7 +68,7 @@ struct acosh_fun {
    * @return Inverse hyperbolic cosine of the argument.
    */
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return acosh(x);
   }
 };

stan/math/prim/fun/asin.hpp

@@ -25,7 +25,7 @@ namespace math {
  */
 struct asin_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::asin;
     return asin(x);
   }

stan/math/prim/fun/asinh.hpp

@@ -29,7 +29,7 @@ namespace math {
  */
 struct asinh_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::asinh;
     return asinh(x);
   }

stan/math/prim/fun/atan.hpp

@@ -23,7 +23,7 @@ namespace math {
  */
 struct atan_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::atan;
     return atan(x);
   }

stan/math/prim/fun/atanh.hpp

@@ -57,7 +57,7 @@ struct atanh_fun {
    * @return Inverse hyperbolic tangent of the argument.
    */
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return atanh(x);
   }
 };

stan/math/prim/fun/cbrt.hpp

@@ -17,7 +17,7 @@ namespace math {
  */
 struct cbrt_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::cbrt;
     return cbrt(x);
   }

stan/math/prim/fun/ceil.hpp

@@ -19,7 +19,7 @@ namespace math {
  */
 struct ceil_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::ceil;
     return ceil(x);
   }

stan/math/prim/fun/cos.hpp

@@ -22,7 +22,7 @@ namespace math {
  */
 struct cos_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::cos;
     return cos(x);
   }

stan/math/prim/fun/cosh.hpp

@@ -21,7 +21,7 @@ namespace math {
  */
 struct cosh_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::cosh;
     return cosh(x);
   }

stan/math/prim/fun/digamma.hpp

@@ -58,7 +58,7 @@ inline double digamma(double x) {
  */
 struct digamma_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return digamma(x);
   }
 };

stan/math/prim/fun/erf.hpp

@@ -17,7 +17,7 @@ namespace math {
  */
 struct erf_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::erf;
     return erf(x);
   }

stan/math/prim/fun/erfc.hpp

@@ -18,7 +18,7 @@ namespace math {
  */
 struct erfc_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::erfc;
     return erfc(x);
   }

stan/math/prim/fun/exp.hpp

@@ -24,7 +24,7 @@ struct exp_fun {
    * @return Exponential of argument.
    */
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::exp;
     return exp(x);
   }

stan/math/prim/fun/exp2.hpp

@@ -20,7 +20,7 @@ struct exp2_fun {
    * @return Base two exponent of the argument.
    */
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::exp2;
     return exp2(x);
   }

stan/math/prim/fun/expm1.hpp

@@ -17,7 +17,7 @@ namespace math {
  */
 struct expm1_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::expm1;
     return expm1(x);
   }

stan/math/prim/fun/fabs.hpp

@@ -11,12 +11,12 @@ namespace stan {
 namespace math {
 
 template <typename T, require_arithmetic_t<T>* = nullptr>
-auto fabs(T x) {
+inline auto fabs(T x) {
   return std::abs(x);
 }
 
 template <typename T, require_complex_t<T>* = nullptr>
-auto fabs(T x) {
+inline auto fabs(T x) {
   return hypot(x.real(), x.imag());
 }
 
@@ -29,7 +29,7 @@ auto fabs(T x) {
  */
 struct fabs_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return fabs(x);
   }
 };

stan/math/prim/fun/floor.hpp

@@ -19,7 +19,7 @@ namespace math {
  */
 struct floor_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::floor;
     return floor(x);
   }

stan/math/prim/fun/inv.hpp

@@ -18,7 +18,7 @@ namespace math {
  */
 struct inv_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return 1.0 / x;
   }
 };

stan/math/prim/fun/inv_Phi.hpp

@@ -160,7 +160,7 @@ inline double inv_Phi(double p) {
  */
 struct inv_Phi_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return inv_Phi(x);
   }
 };

stan/math/prim/fun/inv_cloglog.hpp

@@ -47,7 +47,7 @@ namespace math {
  */
 inline double inv_cloglog(double x) {
   using std::exp;
-  return 1 - exp(-exp(x));
+  return 1. - exp(-exp(x));
 }
 
 /**
@@ -59,7 +59,7 @@ inline double inv_cloglog(double x) {
  */
 struct inv_cloglog_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return inv_cloglog(x);
   }
 };

stan/math/prim/fun/inv_erfc.hpp

@@ -30,7 +30,7 @@ inline auto inv_erfc(const T& x) {
  */
 struct inv_erfc_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return inv_erfc(x);
   }
 };

stan/math/prim/fun/inv_logit.hpp

@@ -69,7 +69,7 @@ inline double inv_logit(double a) {
  */
 struct inv_logit_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return inv_logit(x);
   }
 };

stan/math/prim/fun/inv_sqrt.hpp

@@ -26,7 +26,7 @@ inline auto inv_sqrt(T x) {
  */
 struct inv_sqrt_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return inv_sqrt(x);
   }
 };

stan/math/prim/fun/lambert_w.hpp

@@ -48,7 +48,7 @@ namespace internal {
  */
 struct lambert_w0_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return lambert_w0(x);
   }
 };
@@ -64,7 +64,7 @@ struct lambert_w0_fun {
  */
 struct lambert_wm1_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return lambert_wm1(x);
   }
 };

stan/math/prim/fun/lgamma.hpp

@@ -100,7 +100,7 @@ inline double lgamma(int x) {
  */
 struct lgamma_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return lgamma(x);
   }
 };

stan/math/prim/fun/log.hpp

@@ -27,7 +27,7 @@ struct log_fun {
    * @return Natural log of x.
    */
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::log;
     return log(x);
   }

stan/math/prim/fun/log10.hpp

@@ -21,7 +21,7 @@ namespace math {
  */
 struct log10_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::log10;
     return log10(x);
   }

stan/math/prim/fun/log1m.hpp

@@ -55,7 +55,7 @@ inline double log1m(double x) {
  */
 struct log1m_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return log1m(x);
   }
 };

stan/math/prim/fun/log1m_exp.hpp

@@ -65,7 +65,7 @@ inline double log1m_exp(double a) {
  */
 struct log1m_exp_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return log1m_exp(x);
   }
 };

stan/math/prim/fun/log1m_inv_logit.hpp

@@ -65,7 +65,7 @@ struct log1m_inv_logit_fun {
    * @return natural log of one minus inverse logit of argument
    */
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return log1m_inv_logit(x);
   }
 };

stan/math/prim/fun/log1p.hpp

@@ -61,7 +61,7 @@ struct log1p_fun {
    * @return natural log of one plus the argument
    */
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return log1p(x);
   }
 };

stan/math/prim/fun/log1p_exp.hpp

@@ -60,7 +60,7 @@ inline double log1p_exp(double a) {
  */
 struct log1p_exp_fun {
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     return log1p_exp(x);
   }
 };

stan/math/prim/fun/log2.hpp

@@ -14,7 +14,7 @@ namespace math {
  *
  * @return Natural logarithm of two.
  */
-inline double log2() { return LOG_TWO; }
+inline constexpr double log2() { return LOG_TWO; }
 
 /**
  * Structure to wrap `log2()` so it can be vectorized.
@@ -28,7 +28,7 @@ struct log2_fun {
    * @return base two log of the argument
    */
   template <typename T>
-  static inline T fun(const T& x) {
+  static inline auto fun(const T& x) {
     using std::log2;
     return log2(x);
   }