Add inline to all functions

stan/math/fwd/fun/hypergeometric_1F0.hpp

@@ -31,7 +31,7 @@ namespace math {
 template <typename Ta, typename Tz, typename FvarT = return_type_t<Ta, Tz>,
           require_all_stan_scalar_t<Ta, Tz>* = nullptr,
           require_any_fvar_t<Ta, Tz>* = nullptr>
-FvarT hypergeometric_1F0(const Ta& a, const Tz& z) {
+inline FvarT hypergeometric_1F0(const Ta& a, const Tz& z) {
   partials_type_t<Ta> a_val = value_of(a);
   partials_type_t<Tz> z_val = value_of(z);
   FvarT rtn = FvarT(hypergeometric_1F0(a_val, z_val), 0.0);

stan/math/fwd/fun/polar.hpp

@@ -44,7 +44,7 @@ inline std::complex<fvar<T>> polar(const fvar<T>& r, U theta) {
  * Returns complex number with specified magnitude and phase angle.
  *
  * @tparam T autodiff value type for phase angle
-+* * @tparam U arithmetic type for magnitude
+ * * @tparam U arithmetic type for magnitude
  * @param[in] r magnitude
  * @param[in] theta phase angle
  * @return complex number with magnitude and phase angle

stan/math/fwd/functor/gradient.hpp

@@ -37,8 +37,8 @@ namespace math {
  * @param[out] grad_fx Gradient of function at argument
  */
 template <typename T, typename F>
-void gradient(const F& f, const Eigen::Matrix<T, Eigen::Dynamic, 1>& x, T& fx,
-              Eigen::Matrix<T, Eigen::Dynamic, 1>& grad_fx) {
+inline void gradient(const F& f, const Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
+                     T& fx, Eigen::Matrix<T, Eigen::Dynamic, 1>& grad_fx) {
   Eigen::Matrix<fvar<T>, Eigen::Dynamic, 1> x_fvar(x.size());
   grad_fx.resize(x.size());
   for (int i = 0; i < x.size(); ++i) {

stan/math/fwd/functor/hessian.hpp

@@ -38,9 +38,9 @@ namespace math {
  * @param[out] H Hessian of function at argument
  */
 template <typename T, typename F>
-void hessian(const F& f, const Eigen::Matrix<T, Eigen::Dynamic, 1>& x, T& fx,
-             Eigen::Matrix<T, Eigen::Dynamic, 1>& grad,
-             Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& H) {
+inline void hessian(const F& f, const Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
+                    T& fx, Eigen::Matrix<T, Eigen::Dynamic, 1>& grad,
+                    Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& H) {
   H.resize(x.size(), x.size());
   grad.resize(x.size());
   // size 0 separate because nothing to loop over in main body

stan/math/fwd/functor/jacobian.hpp

@@ -8,9 +8,9 @@ namespace stan {
 namespace math {
 
 template <typename T, typename F>
-void jacobian(const F& f, const Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
-              Eigen::Matrix<T, Eigen::Dynamic, 1>& fx,
-              Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& J) {
+inline void jacobian(const F& f, const Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
+                     Eigen::Matrix<T, Eigen::Dynamic, 1>& fx,
+                     Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic>& J) {
   using Eigen::Dynamic;
   using Eigen::Matrix;
   Matrix<fvar<T>, Dynamic, 1> x_fvar(x.size());

stan/math/memory/stack_alloc.hpp

@@ -26,7 +26,7 @@ namespace math {
  * @tparam Type of object to which pointer points.
  */
 template <typename T>
-bool is_aligned(T* ptr, unsigned int bytes_aligned) {
+inline bool is_aligned(T* ptr, unsigned int bytes_aligned) {
   return (reinterpret_cast<uintptr_t>(ptr) % bytes_aligned) == 0U;
 }
 

stan/math/mix/functor/hessian_times_vector.hpp

@@ -38,10 +38,10 @@ inline void hessian_times_vector(
 template <typename T, typename F, typename EigVec,
           require_eigen_vector_t<EigVec>* = nullptr,
           require_stan_scalar_t<T>* = nullptr>
-void hessian_times_vector(const F& f,
-                          const Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
-                          const EigVec& v, T& fx,
-                          Eigen::Matrix<T, Eigen::Dynamic, 1>& Hv) {
+inline void hessian_times_vector(const F& f,
+                                 const Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
+                                 const EigVec& v, T& fx,
+                                 Eigen::Matrix<T, Eigen::Dynamic, 1>& Hv) {
   using Eigen::Matrix;
   Matrix<T, Eigen::Dynamic, 1> grad;
   Matrix<T, Eigen::Dynamic, Eigen::Dynamic> H;

stan/math/mix/functor/partial_derivative.hpp

@@ -22,9 +22,9 @@ namespace math {
  * @param[out] dfx_dxn Value of partial derivative
  */
 template <typename T, typename F>
-void partial_derivative(const F& f,
-                        const Eigen::Matrix<T, Eigen::Dynamic, 1>& x, int n,
-                        T& fx, T& dfx_dxn) {
+inline void partial_derivative(const F& f,
+                               const Eigen::Matrix<T, Eigen::Dynamic, 1>& x,
+                               int n, T& fx, T& dfx_dxn) {
   Eigen::Matrix<fvar<T>, Eigen::Dynamic, 1> x_fvar(x.size());
   for (int i = 0; i < x.size(); ++i) {
     x_fvar(i) = fvar<T>(x(i), i == n);

stan/math/opencl/copy.hpp

@@ -232,7 +232,7 @@ inline T_dst from_matrix_cl(const matrix_cl<T>& src) {
  * @return Eigen matrix with a copy of the data in the source matrix
  */
 template <typename T, require_all_kernel_expressions_t<T>* = nullptr>
-auto from_matrix_cl(const T& src) {
+inline auto from_matrix_cl(const T& src) {
   return from_matrix_cl<
       Eigen::Matrix<scalar_type_t<T>, Eigen::Dynamic, Eigen::Dynamic>>(src);
 }

stan/math/opencl/indexing_rev.hpp

@@ -19,8 +19,8 @@ namespace math {
  * @param idx indices
  * @param res adjoint of the result of the indexing operation
  */
-void indexing_rev(matrix_cl<double>& adj, const matrix_cl<int>& idx,
-                  const matrix_cl<double>& res) {
+inline void indexing_rev(matrix_cl<double>& adj, const matrix_cl<int>& idx,
+                         const matrix_cl<double>& res) {
   int local_mem_size
       = opencl_context.device()[0].getInfo<CL_DEVICE_LOCAL_MEM_SIZE>();
   int preferred_work_groups

stan/math/opencl/kernel_generator/evaluate_into.hpp

@@ -18,7 +18,8 @@ namespace math {
  */
 template <typename Derived, typename Scalar, typename... Args>
 template <typename T_lhs>
-void operation_cl<Derived, Scalar, Args...>::evaluate_into(T_lhs& lhs) const {
+inline void operation_cl<Derived, Scalar, Args...>::evaluate_into(
+    T_lhs& lhs) const {
   static_assert(
       is_kernel_expression<T_lhs>::value,
       "operation_cl::evaluate_into: left hand side is not a valid expression!");

stan/math/opencl/kernel_generator/holder_cl.hpp

@@ -64,7 +64,7 @@ class holder_cl_
  */
 template <typename T, typename... Ptrs,
           require_all_kernel_expressions_t<T, Ptrs...>* = nullptr>
-auto holder_cl(T&& a, Ptrs*... ptrs) {
+inline auto holder_cl(T&& a, Ptrs*... ptrs) {
   return holder_cl_<as_operation_cl_t<T>, Ptrs...>(
       as_operation_cl(std::forward<T>(a)), ptrs...);
 }
@@ -81,8 +81,8 @@ namespace internal {
  * @return `holder_cl` referencing given expression
  */
 template <typename T, std::size_t... Is, typename... Args>
-auto make_holder_cl_impl_step2(T&& expr, std::index_sequence<Is...>,
-                               const std::tuple<Args*...>& ptrs) {
+inline auto make_holder_cl_impl_step2(T&& expr, std::index_sequence<Is...>,
+                                      const std::tuple<Args*...>& ptrs) {
   return holder_cl(std::forward<T>(expr), std::get<Is>(ptrs)...);
 }
 
@@ -96,8 +96,8 @@ auto make_holder_cl_impl_step2(T&& expr, std::index_sequence<Is...>,
  * @return `holder_cl` referencing given expression
  */
 template <typename T, std::size_t... Is, typename... Args>
-auto make_holder_cl_impl_step1(const T& func, std::index_sequence<Is...>,
-                               Args&&... args) {
+inline auto make_holder_cl_impl_step1(const T& func, std::index_sequence<Is...>,
+                                      Args&&... args) {
   std::tuple<std::remove_reference_t<Args>*...> res;
   auto ptrs = std::tuple_cat(
       holder_handle_element(std::forward<Args>(args), std::get<Is>(res))...);
@@ -122,7 +122,7 @@ template <typename T, typename... Args,
           require_all_kernel_expressions_t<
               decltype(std::declval<T>()(std::declval<Args&>()...)),
               Args...>* = nullptr>
-auto make_holder_cl(const T& func, Args&&... args) {
+inline auto make_holder_cl(const T& func, Args&&... args) {
   return internal::make_holder_cl_impl_step1(
       func, std::make_index_sequence<sizeof...(Args)>(),
       std::forward<Args>(args)...);

stan/math/opencl/kernel_generator/multi_result_kernel.hpp

@@ -665,7 +665,7 @@ class results_cl {
  * @param results results that will be calculated in same kernel.
  */
 template <typename... T_results>
-results_cl<T_results...> results(T_results&&... results) {
+inline results_cl<T_results...> results(T_results&&... results) {
   return results_cl<T_results...>(std::forward<T_results>(results)...);
 }
 

stan/math/opencl/prim/bernoulli_cdf.hpp

@@ -27,8 +27,8 @@ template <
     typename T_n_cl, typename T_prob_cl,
     require_all_prim_or_rev_kernel_expression_t<T_n_cl, T_prob_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_n_cl, T_prob_cl>* = nullptr>
-return_type_t<T_prob_cl> bernoulli_cdf(const T_n_cl& n,
-                                       const T_prob_cl& theta) {
+inline return_type_t<T_prob_cl> bernoulli_cdf(const T_n_cl& n,
+                                              const T_prob_cl& theta) {
   static constexpr const char* function = "bernoulli_cdf(OpenCL)";
   using T_partials_return = partials_return_t<T_prob_cl>;
   using std::isnan;

stan/math/opencl/prim/bernoulli_lccdf.hpp

@@ -28,8 +28,8 @@ template <
     typename T_n_cl, typename T_prob_cl,
     require_all_prim_or_rev_kernel_expression_t<T_n_cl, T_prob_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_n_cl, T_prob_cl>* = nullptr>
-return_type_t<T_prob_cl> bernoulli_lccdf(const T_n_cl& n,
-                                         const T_prob_cl& theta) {
+inline return_type_t<T_prob_cl> bernoulli_lccdf(const T_n_cl& n,
+                                                const T_prob_cl& theta) {
   static constexpr const char* function = "bernoulli_lccdf(OpenCL)";
   using T_partials_return = partials_return_t<T_prob_cl>;
   using std::isnan;

stan/math/opencl/prim/bernoulli_lcdf.hpp

@@ -28,8 +28,8 @@ template <
     typename T_n_cl, typename T_prob_cl,
     require_all_prim_or_rev_kernel_expression_t<T_n_cl, T_prob_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_n_cl, T_prob_cl>* = nullptr>
-return_type_t<T_prob_cl> bernoulli_lcdf(const T_n_cl& n,
-                                        const T_prob_cl& theta) {
+inline return_type_t<T_prob_cl> bernoulli_lcdf(const T_n_cl& n,
+                                               const T_prob_cl& theta) {
   static constexpr const char* function = "bernoulli_lcdf(OpenCL)";
   using T_partials_return = partials_return_t<T_prob_cl>;
   using std::isnan;

stan/math/opencl/prim/bernoulli_logit_glm_lpmf.hpp

@@ -53,7 +53,7 @@ template <bool propto, typename T_x_cl, typename T_y_cl, typename T_alpha_cl,
           typename T_beta_cl,
           require_all_prim_or_rev_kernel_expression_t<
               T_y_cl, T_x_cl, T_alpha_cl, T_beta_cl>* = nullptr>
-return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> bernoulli_logit_glm_lpmf(
+inline return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> bernoulli_logit_glm_lpmf(
     const T_y_cl& y, const T_x_cl& x, const T_alpha_cl& alpha,
     const T_beta_cl& beta) {
   static constexpr const char* function = "bernoulli_logit_glm_lpmf(OpenCL)";

stan/math/opencl/prim/bernoulli_logit_lpmf.hpp

@@ -26,8 +26,8 @@ template <
     bool propto, typename T_n_cl, typename T_prob_cl,
     require_all_prim_or_rev_kernel_expression_t<T_n_cl, T_prob_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_n_cl, T_prob_cl>* = nullptr>
-return_type_t<T_prob_cl> bernoulli_logit_lpmf(const T_n_cl& n,
-                                              const T_prob_cl& theta) {
+inline return_type_t<T_prob_cl> bernoulli_logit_lpmf(const T_n_cl& n,
+                                                     const T_prob_cl& theta) {
   static constexpr const char* function = "bernoulli_logit_lpmf(OpenCL)";
   using T_partials_return = partials_return_t<T_prob_cl>;
   using std::isnan;

stan/math/opencl/prim/bernoulli_lpmf.hpp

@@ -29,8 +29,8 @@ template <
     bool propto, typename T_n_cl, typename T_prob_cl,
     require_all_prim_or_rev_kernel_expression_t<T_n_cl, T_prob_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_n_cl, T_prob_cl>* = nullptr>
-return_type_t<T_prob_cl> bernoulli_lpmf(const T_n_cl& n,
-                                        const T_prob_cl& theta) {
+inline return_type_t<T_prob_cl> bernoulli_lpmf(const T_n_cl& n,
+                                               const T_prob_cl& theta) {
   static constexpr const char* function = "bernoulli_lpmf(OpenCL)";
   using T_partials_return = partials_return_t<T_prob_cl>;
   constexpr bool is_n_vector = !is_stan_scalar<T_n_cl>::value;

stan/math/opencl/prim/beta_binomial_lpmf.hpp

@@ -40,7 +40,7 @@ template <
     require_all_prim_or_rev_kernel_expression_t<T_n_cl, T_size1_cl,
                                                 T_size2_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_n_cl, T_size1_cl, T_size2_cl>* = nullptr>
-return_type_t<T_n_cl, T_size1_cl, T_size2_cl> beta_binomial_lpmf(
+inline return_type_t<T_n_cl, T_size1_cl, T_size2_cl> beta_binomial_lpmf(
     const T_n_cl& n, const T_N_cl N, const T_size1_cl& alpha,
     const T_size2_cl& beta) {
   using std::isfinite;

stan/math/opencl/prim/beta_lpdf.hpp

@@ -40,7 +40,7 @@ template <bool propto, typename T_y_cl, typename T_scale_succ_cl,
               T_y_cl, T_scale_succ_cl, T_scale_fail_cl>* = nullptr,
           require_any_not_stan_scalar_t<T_y_cl, T_scale_succ_cl,
                                         T_scale_fail_cl>* = nullptr>
-return_type_t<T_y_cl, T_scale_succ_cl, T_scale_fail_cl> beta_lpdf(
+inline return_type_t<T_y_cl, T_scale_succ_cl, T_scale_fail_cl> beta_lpdf(
     const T_y_cl& y, const T_scale_succ_cl& alpha,
     const T_scale_fail_cl& beta) {
   using std::isfinite;

stan/math/opencl/prim/beta_proportion_lpdf.hpp

@@ -39,7 +39,7 @@ template <bool propto, typename T_y_cl, typename T_loc_cl, typename T_prec_cl,
           require_all_prim_or_rev_kernel_expression_t<T_y_cl, T_loc_cl,
                                                       T_prec_cl>* = nullptr,
           require_any_not_stan_scalar_t<T_y_cl, T_loc_cl, T_prec_cl>* = nullptr>
-return_type_t<T_y_cl, T_loc_cl, T_prec_cl> beta_proportion_lpdf(
+inline return_type_t<T_y_cl, T_loc_cl, T_prec_cl> beta_proportion_lpdf(
     const T_y_cl& y, const T_loc_cl& mu, const T_prec_cl& kappa) {
   static constexpr const char* function = "beta_proportion_lpdf(OpenCL)";
   using T_partials_return = partials_return_t<T_y_cl, T_loc_cl, T_prec_cl>;

stan/math/opencl/prim/binomial_logit_glm_lpmf.hpp

@@ -29,7 +29,7 @@ template <bool propto, typename T_n_cl, typename T_N_cl, typename T_x_cl,
           typename T_alpha_cl, typename T_beta_cl,
           require_all_prim_or_rev_kernel_expression_t<
               T_n_cl, T_N_cl, T_x_cl, T_alpha_cl, T_beta_cl>* = nullptr>
-return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> binomial_logit_glm_lpmf(
+inline return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> binomial_logit_glm_lpmf(
     const T_n_cl& n, const T_N_cl& N, const T_x_cl& x, const T_alpha_cl& alpha,
     const T_beta_cl& beta) {
   static const char* function = "binomial_logit_glm_lpmf(OpenCL)";

stan/math/opencl/prim/binomial_logit_lpmf.hpp

@@ -31,8 +31,9 @@ template <bool propto, typename T_n_cl, typename T_N_cl, typename T_prob_cl,
                                                       T_prob_cl>* = nullptr,
           require_any_nonscalar_prim_or_rev_kernel_expression_t<
               T_n_cl, T_N_cl, T_prob_cl>* = nullptr>
-return_type_t<T_prob_cl> binomial_logit_lpmf(const T_n_cl& n, const T_N_cl N,
-                                             const T_prob_cl& alpha) {
+inline return_type_t<T_prob_cl> binomial_logit_lpmf(const T_n_cl& n,
+                                                    const T_N_cl N,
+                                                    const T_prob_cl& alpha) {
   static constexpr const char* function = "binomial_logit_lpmf(OpenCL)";
   using T_partials_return = partials_return_t<T_prob_cl>;
   using std::isfinite;

stan/math/opencl/prim/binomial_lpmf.hpp

@@ -33,8 +33,8 @@ template <bool propto, typename T_n_cl, typename T_N_cl, typename T_prob_cl,
                                                       T_prob_cl>* = nullptr,
           require_any_nonscalar_prim_or_rev_kernel_expression_t<
               T_n_cl, T_N_cl, T_prob_cl>* = nullptr>
-return_type_t<T_prob_cl> binomial_lpmf(const T_n_cl& n, const T_N_cl N,
-                                       const T_prob_cl& theta) {
+inline return_type_t<T_prob_cl> binomial_lpmf(const T_n_cl& n, const T_N_cl N,
+                                              const T_prob_cl& theta) {
   static constexpr const char* function = "binomial_lpmf(OpenCL)";
   using T_partials_return = partials_return_t<T_prob_cl>;
   using std::isnan;

stan/math/opencl/prim/categorical_logit_glm_lpmf.hpp

@@ -46,7 +46,7 @@ template <bool propto, typename T_y, typename T_x, typename T_alpha,
           typename T_beta,
           require_all_prim_or_rev_kernel_expression_t<T_y, T_x, T_alpha,
                                                       T_beta>* = nullptr>
-return_type_t<T_x, T_alpha, T_beta> categorical_logit_glm_lpmf(
+inline return_type_t<T_x, T_alpha, T_beta> categorical_logit_glm_lpmf(
     const T_y& y, const T_x& x, const T_alpha& alpha, const T_beta& beta) {
   using T_partials_return = partials_return_t<T_x, T_alpha, T_beta>;
   constexpr bool is_y_vector = !is_stan_scalar<T_y>::value;

stan/math/opencl/prim/cauchy_cdf.hpp

@@ -31,7 +31,7 @@ template <
     require_all_prim_or_rev_kernel_expression_t<T_y_cl, T_loc_cl,
                                                 T_scale_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_y_cl, T_loc_cl, T_scale_cl>* = nullptr>
-return_type_t<T_y_cl, T_loc_cl, T_scale_cl> cauchy_cdf(
+inline return_type_t<T_y_cl, T_loc_cl, T_scale_cl> cauchy_cdf(
     const T_y_cl& y, const T_loc_cl& mu, const T_scale_cl& sigma) {
   static constexpr const char* function = "cauchy_cdf(OpenCL)";
   using T_partials_return = partials_return_t<T_y_cl, T_loc_cl, T_scale_cl>;

stan/math/opencl/prim/cauchy_lccdf.hpp

@@ -31,7 +31,7 @@ template <
     require_all_prim_or_rev_kernel_expression_t<T_y_cl, T_loc_cl,
                                                 T_scale_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_y_cl, T_loc_cl, T_scale_cl>* = nullptr>
-return_type_t<T_y_cl, T_loc_cl, T_scale_cl> cauchy_lccdf(
+inline return_type_t<T_y_cl, T_loc_cl, T_scale_cl> cauchy_lccdf(
     const T_y_cl& y, const T_loc_cl& mu, const T_scale_cl& sigma) {
   static constexpr const char* function = "cauchy_lccdf(OpenCL)";
   using T_partials_return = partials_return_t<T_y_cl, T_loc_cl, T_scale_cl>;

stan/math/opencl/prim/cauchy_lcdf.hpp

@@ -31,7 +31,7 @@ template <
     require_all_prim_or_rev_kernel_expression_t<T_y_cl, T_loc_cl,
                                                 T_scale_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_y_cl, T_loc_cl, T_scale_cl>* = nullptr>
-return_type_t<T_y_cl, T_loc_cl, T_scale_cl> cauchy_lcdf(
+inline return_type_t<T_y_cl, T_loc_cl, T_scale_cl> cauchy_lcdf(
     const T_y_cl& y, const T_loc_cl& mu, const T_scale_cl& sigma) {
   static constexpr const char* function = "cauchy_lcdf(OpenCL)";
   using T_partials_return = partials_return_t<T_y_cl, T_loc_cl, T_scale_cl>;

stan/math/opencl/prim/cauchy_lpdf.hpp

@@ -35,7 +35,7 @@ template <
     require_all_prim_or_rev_kernel_expression_t<T_y_cl, T_loc_cl,
                                                 T_scale_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_y_cl, T_loc_cl, T_scale_cl>* = nullptr>
-return_type_t<T_y_cl, T_loc_cl, T_scale_cl> cauchy_lpdf(
+inline return_type_t<T_y_cl, T_loc_cl, T_scale_cl> cauchy_lpdf(
     const T_y_cl& y, const T_loc_cl& mu, const T_scale_cl& sigma) {
   static constexpr const char* function = "cauchy_lpdf(OpenCL)";
   using T_partials_return = partials_return_t<T_y_cl, T_loc_cl, T_scale_cl>;

stan/math/opencl/prim/chi_square_lpdf.hpp

@@ -35,8 +35,8 @@ template <
     bool propto, typename T_y_cl, typename T_dof_cl,
     require_all_prim_or_rev_kernel_expression_t<T_y_cl, T_dof_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_y_cl, T_dof_cl>* = nullptr>
-return_type_t<T_y_cl, T_dof_cl> chi_square_lpdf(const T_y_cl& y,
-                                                const T_dof_cl& nu) {
+inline return_type_t<T_y_cl, T_dof_cl> chi_square_lpdf(const T_y_cl& y,
+                                                       const T_dof_cl& nu) {
   static constexpr const char* function = "chi_square_lpdf(OpenCL)";
   using T_partials_return = partials_return_t<T_y_cl, T_dof_cl>;
   using std::isfinite;

stan/math/opencl/prim/double_exponential_cdf.hpp

@@ -30,7 +30,7 @@ template <
     require_all_prim_or_rev_kernel_expression_t<T_y_cl, T_loc_cl,
                                                 T_scale_cl>* = nullptr,
     require_any_not_stan_scalar_t<T_y_cl, T_loc_cl, T_scale_cl>* = nullptr>
-return_type_t<T_y_cl, T_loc_cl, T_scale_cl> double_exponential_cdf(
+inline return_type_t<T_y_cl, T_loc_cl, T_scale_cl> double_exponential_cdf(
     const T_y_cl& y, const T_loc_cl& mu, const T_scale_cl& sigma) {
   static constexpr const char* function = "double_exponential_cdf(OpenCL)";
   using T_partials_return = partials_return_t<T_y_cl, T_loc_cl, T_scale_cl>;