Clean up if Jacobian and non-inline auto

Author: WardBrian

stan/math/prim/constraint/cholesky_corr_free.hpp

@@ -11,7 +11,7 @@ namespace stan {
 namespace math {
 
 template <typename T, require_eigen_t<T>* = nullptr>
-auto cholesky_corr_free(const T& x) {
+inline auto cholesky_corr_free(const T& x) {
   using Eigen::Dynamic;
   using Eigen::Matrix;
   using std::sqrt;
@@ -42,7 +42,7 @@ auto cholesky_corr_free(const T& x) {
  * @param x The standard vector to untransform.
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-auto cholesky_corr_free(const T& x) {
+inline auto cholesky_corr_free(const T& x) {
   return apply_vector_unary<T>::apply(
       x, [](auto&& v) { return cholesky_corr_free(v); });
 }

stan/math/prim/constraint/cholesky_factor_free.hpp

@@ -56,7 +56,7 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cholesky_factor_free(
  * @param x The standard vector to untransform.
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-auto cholesky_factor_free(const T& x) {
+inline auto cholesky_factor_free(const T& x) {
   return apply_vector_unary<T>::apply(
       x, [](auto&& v) { return cholesky_factor_free(v); });
 }

stan/math/prim/constraint/corr_constrain.hpp

@@ -66,7 +66,7 @@ inline auto corr_constrain(const T_x& x, T_lp& lp) {
  */
 template <bool Jacobian, typename T_x, typename T_lp>
 inline auto corr_constrain(const T_x& x, T_lp& lp) {
-  if (Jacobian) {
+  if constexpr (Jacobian) {
     return corr_constrain(x, lp);
   } else {
     return corr_constrain(x);

stan/math/prim/constraint/corr_free.hpp

@@ -25,7 +25,7 @@ namespace math {
  * @return free scalar that transforms to the specified input
  */
 template <typename T>
-inline T corr_free(const T& y) {
+inline plain_type_t<T> corr_free(const T& y) {
   check_bounded("lub_free", "Correlation variable", y, -1.0, 1.0);
   return atanh(y);
 }

stan/math/prim/constraint/corr_matrix_free.hpp

@@ -60,7 +60,7 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> corr_matrix_free(const T& y) {
  * @param x The standard vector to untransform.
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-auto corr_matrix_free(const T& x) {
+inline auto corr_matrix_free(const T& x) {
   return apply_vector_unary<T>::apply(
       x, [](auto&& v) { return corr_matrix_free(v); });
 }

stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp

@@ -86,7 +86,7 @@ cov_matrix_constrain_lkj(const T& x, size_t k, return_type_t<T>& lp) {
 template <bool Jacobian, typename T, require_not_std_vector_t<T>* = nullptr>
 inline auto cov_matrix_constrain_lkj(const T& x, size_t k,
                                      return_type_t<T>& lp) {
-  if (Jacobian) {
+  if constexpr (Jacobian) {
     return cov_matrix_constrain_lkj(x, k, lp);
   } else {
     return cov_matrix_constrain_lkj(x, k);

stan/math/prim/constraint/cov_matrix_free.hpp

@@ -66,7 +66,7 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cov_matrix_free(const T& y) {
  * @param x The standard vector to untransform.
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-auto cov_matrix_free(const T& x) {
+inline auto cov_matrix_free(const T& x) {
   return apply_vector_unary<T>::apply(
       x, [](auto&& v) { return cov_matrix_free(v); });
 }

stan/math/prim/constraint/lb_constrain.hpp

@@ -256,7 +256,7 @@ inline auto lb_constrain(const std::vector<T>& x, const std::vector<L>& lb,
 template <bool Jacobian, typename T, typename L, typename Lp,
           require_convertible_t<return_type_t<T, L>, Lp>* = nullptr>
 inline auto lb_constrain(const T& x, const L& lb, Lp& lp) {
-  if (Jacobian) {
+  if constexpr (Jacobian) {
     return lb_constrain(x, lb, lp);
   } else {
     return lb_constrain(x, lb);

stan/math/prim/constraint/lub_constrain.hpp

@@ -399,7 +399,7 @@ inline auto lub_constrain(const std::vector<T>& x, const std::vector<L>& lb,
 template <bool Jacobian, typename T, typename L, typename U, typename Lp,
           require_convertible_t<return_type_t<T, L, U>, Lp>* = nullptr>
 inline auto lub_constrain(const T& x, const L& lb, const U& ub, Lp& lp) {
-  if (Jacobian) {
+  if constexpr (Jacobian) {
     return lub_constrain(x, lb, ub, lp);
   } else {
     return lub_constrain(x, lb, ub);

stan/math/prim/constraint/offset_multiplier_constrain.hpp

@@ -185,8 +185,8 @@ template <typename T, typename M, typename S, typename Lp,
 inline auto offset_multiplier_constrain(const std::vector<T>& x, const M& mu,
                                         const std::vector<S>& sigma, Lp& lp) {
   check_matching_dims("offset_multiplier_constrain", "x", x, "sigma", sigma);
-  std::vector<plain_type_t<decltype(
-      offset_multiplier_constrain(x[0], mu, sigma[0], lp))>>
+  std::vector<plain_type_t<decltype(offset_multiplier_constrain(x[0], mu,
+                                                                sigma[0], lp))>>
       ret;
   ret.reserve(x.size());
   const auto& mu_ref = to_ref(mu);
@@ -226,8 +226,8 @@ inline auto offset_multiplier_constrain(const std::vector<T>& x,
                                         const std::vector<M>& mu,
                                         const S& sigma, Lp& lp) {
   check_matching_dims("offset_multiplier_constrain", "x", x, "mu", mu);
-  std::vector<plain_type_t<decltype(
-      offset_multiplier_constrain(x[0], mu[0], sigma, lp))>>
+  std::vector<plain_type_t<decltype(offset_multiplier_constrain(x[0], mu[0],
+                                                                sigma, lp))>>
       ret;
   ret.reserve(x.size());
   const auto& sigma_ref = to_ref(sigma);
@@ -246,8 +246,8 @@ inline auto offset_multiplier_constrain(const std::vector<T>& x,
                                         const std::vector<S>& sigma) {
   check_matching_dims("offset_multiplier_constrain", "x", x, "mu", mu);
   check_matching_dims("offset_multiplier_constrain", "x", x, "sigma", sigma);
-  std::vector<plain_type_t<decltype(
-      offset_multiplier_constrain(x[0], mu[0], sigma[0]))>>
+  std::vector<plain_type_t<decltype(offset_multiplier_constrain(x[0], mu[0],
+                                                                sigma[0]))>>
       ret;
   ret.reserve(x.size());
   for (size_t i = 0; i < x.size(); ++i) {
@@ -266,8 +266,8 @@ inline auto offset_multiplier_constrain(const std::vector<T>& x,
                                         const std::vector<S>& sigma, Lp& lp) {
   check_matching_dims("offset_multiplier_constrain", "x", x, "mu", mu);
   check_matching_dims("offset_multiplier_constrain", "x", x, "sigma", sigma);
-  std::vector<plain_type_t<decltype(
-      offset_multiplier_constrain(x[0], mu[0], sigma[0], lp))>>
+  std::vector<plain_type_t<decltype(offset_multiplier_constrain(x[0], mu[0],
+                                                                sigma[0], lp))>>
       ret;
   ret.reserve(x.size());
   for (size_t i = 0; i < x.size(); ++i) {
@@ -305,7 +305,7 @@ template <bool Jacobian, typename T, typename M, typename S, typename Lp,
           require_convertible_t<return_type_t<T, M, S>, Lp>* = nullptr>
 inline auto offset_multiplier_constrain(const T& x, const M& mu, const S& sigma,
                                         Lp& lp) {
-  if (Jacobian) {
+  if constexpr (Jacobian) {
     return offset_multiplier_constrain(x, mu, sigma, lp);
   } else {
     return offset_multiplier_constrain(x, mu, sigma);