Merge branch 'develop' into feature/multinomial_logit

Author: nhuurre

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: stan-dev
+custom: https://mc-stan.org/support/

stan/math/fwd/core/operator_division.hpp

@@ -31,7 +31,7 @@ inline fvar<T> operator/(const fvar<T>& x1, const fvar<T>& x2) {
  * @param x2 second argument
  * @return first argument divided by second argument
  */
-template <typename T, typename U, require_arithmetic_t<U>...>
+template <typename T, typename U, require_arithmetic_t<U>* = nullptr>
 inline fvar<T> operator/(const fvar<T>& x1, U x2) {
   return fvar<T>(x1.val_ / x2, x1.d_ / x2);
 }
@@ -44,7 +44,7 @@ inline fvar<T> operator/(const fvar<T>& x1, U x2) {
  * @param x2 second argument
  * @return first argument divided by second argument
  */
-template <typename T, typename U, require_arithmetic_t<U>...>
+template <typename T, typename U, require_arithmetic_t<U>* = nullptr>
 inline fvar<T> operator/(U x1, const fvar<T>& x2) {
   return fvar<T>(x1 / x2.val_, -x1 * x2.d_ / (x2.val_ * x2.val_));
 }
@@ -54,7 +54,7 @@ inline std::complex<fvar<T>> operator/(const std::complex<fvar<T>>& x1,
                                        const std::complex<fvar<T>>& x2) {
   return internal::complex_divide(x1, x2);
 }
-template <typename T, typename U, require_arithmetic_t<U>...>
+template <typename T, typename U, require_arithmetic_t<U>* = nullptr>
 inline std::complex<fvar<T>> operator/(const std::complex<fvar<T>>& x1,
                                        const std::complex<U>& x2) {
   return internal::complex_divide(x1, x2);
@@ -64,17 +64,17 @@ inline std::complex<fvar<T>> operator/(const std::complex<fvar<T>>& x1,
                                        const fvar<T>& x2) {
   return internal::complex_divide(x1, x2);
 }
-template <typename T, typename U, require_arithmetic_t<U>...>
+template <typename T, typename U, require_arithmetic_t<U>* = nullptr>
 inline std::complex<fvar<T>> operator/(const std::complex<fvar<T>>& x1, U x2) {
   return internal::complex_divide(x1, x2);
 }
 
-template <typename T, typename U, require_arithmetic_t<U>...>
+template <typename T, typename U, require_arithmetic_t<U>* = nullptr>
 inline std::complex<fvar<T>> operator/(const std::complex<U>& x1,
                                        const std::complex<fvar<T>>& x2) {
   return internal::complex_divide(x1, x2);
 }
-template <typename T, typename U, require_arithmetic_t<U>...>
+template <typename T, typename U, require_arithmetic_t<U>* = nullptr>
 inline std::complex<fvar<T>> operator/(const std::complex<U>& x1,
                                        const fvar<T>& x2) {
   return internal::complex_divide(x1, x2);
@@ -92,7 +92,7 @@ inline std::complex<fvar<T>> operator/(const fvar<T>& x1,
   return internal::complex_divide(x1, x2);
 }
 
-template <typename T, typename U, require_arithmetic_t<U>...>
+template <typename T, typename U, require_arithmetic_t<U>* = nullptr>
 inline std::complex<fvar<T>> operator/(U x1, const std::complex<fvar<T>>& x2) {
   return internal::complex_divide(x1, x2);
 }

stan/math/fwd/fun/is_nan.hpp

@@ -18,7 +18,7 @@ namespace math {
  * @param x Value to test.
  * @return <code>1</code> if the value is NaN and <code>0</code> otherwise.
  */
-template <typename T, require_fvar_t<T>...>
+template <typename T, require_fvar_t<T>* = nullptr>
 inline bool is_nan(T&& x) {
   return is_nan(std::forward<decltype(x.val())>(x.val()));
 }

stan/math/fwd/fun/log_mix.hpp

@@ -114,7 +114,7 @@ inline fvar<T> log_mix(const fvar<T>& theta, const fvar<T>& lambda1,
   }
 }
 
-template <typename T, typename P, require_all_arithmetic_t<P>...>
+template <typename T, typename P, require_all_arithmetic_t<P>* = nullptr>
 inline fvar<T> log_mix(const fvar<T>& theta, const fvar<T>& lambda1,
                        P lambda2) {
   if (lambda1.val_ > lambda2) {
@@ -132,7 +132,7 @@ inline fvar<T> log_mix(const fvar<T>& theta, const fvar<T>& lambda1,
   }
 }
 
-template <typename T, typename P, require_all_arithmetic_t<P>...>
+template <typename T, typename P, require_all_arithmetic_t<P>* = nullptr>
 inline fvar<T> log_mix(const fvar<T>& theta, P lambda1,
                        const fvar<T>& lambda2) {
   if (lambda1 > lambda2.val_) {
@@ -150,7 +150,7 @@ inline fvar<T> log_mix(const fvar<T>& theta, P lambda1,
   }
 }
 
-template <typename T, typename P, require_all_arithmetic_t<P>...>
+template <typename T, typename P, require_all_arithmetic_t<P>* = nullptr>
 inline fvar<T> log_mix(P theta, const fvar<T>& lambda1,
                        const fvar<T>& lambda2) {
   if (lambda1.val_ > lambda2.val_) {
@@ -169,7 +169,7 @@ inline fvar<T> log_mix(P theta, const fvar<T>& lambda1,
 }
 
 template <typename T, typename P1, typename P2,
-          require_all_arithmetic_t<P1, P2>...>
+          require_all_arithmetic_t<P1, P2>* = nullptr>
 inline fvar<T> log_mix(const fvar<T>& theta, P1 lambda1, P2 lambda2) {
   if (lambda1 > lambda2) {
     fvar<T> partial_deriv_array[1];
@@ -185,7 +185,7 @@ inline fvar<T> log_mix(const fvar<T>& theta, P1 lambda1, P2 lambda2) {
 }
 
 template <typename T, typename P1, typename P2,
-          require_all_arithmetic_t<P1, P2>...>
+          require_all_arithmetic_t<P1, P2>* = nullptr>
 inline fvar<T> log_mix(P1 theta, const fvar<T>& lambda1, P2 lambda2) {
   if (lambda1.val_ > lambda2) {
     fvar<T> partial_deriv_array[1];
@@ -201,7 +201,7 @@ inline fvar<T> log_mix(P1 theta, const fvar<T>& lambda1, P2 lambda2) {
 }
 
 template <typename T, typename P1, typename P2,
-          require_all_arithmetic_t<P1, P2>...>
+          require_all_arithmetic_t<P1, P2>* = nullptr>
 inline fvar<T> log_mix(P1 theta, P2 lambda1, const fvar<T>& lambda2) {
   if (lambda1 > lambda2.val_) {
     fvar<T> partial_deriv_array[1];

stan/math/fwd/fun/log_sum_exp.hpp

@@ -50,7 +50,7 @@ inline fvar<T> log_sum_exp(const fvar<T>& x1, double x2) {
  * @param[in] x Matrix of specified values.
  * @return The log of the sum of the exponentiated vector values.
  */
-template <typename T, require_container_st<is_fvar, T>...>
+template <typename T, require_container_st<is_fvar, T>* = nullptr>
 inline auto log_sum_exp(const T& x) {
   return apply_vector_unary<T>::reduce(x, [&](const auto& v) {
     using T_fvar_inner = typename value_type_t<decltype(v)>::Scalar;

stan/math/opencl/copy.hpp

@@ -41,7 +41,7 @@ namespace math {
  * @return matrix_cl with a copy of the data in the source matrix
  */
 template <typename Mat, typename Mat_scalar = scalar_type_t<Mat>,
-          require_eigen_vt<std::is_arithmetic, Mat>...>
+          require_eigen_vt<std::is_arithmetic, Mat>* = nullptr>
 inline matrix_cl<Mat_scalar> to_matrix_cl(Mat&& src) {
   return matrix_cl<Mat_scalar>(std::forward<Mat>(src));
 }
@@ -60,7 +60,7 @@ inline matrix_cl<Mat_scalar> to_matrix_cl(Mat&& src) {
  * @return matrix_cl with a copy of the data in the source matrix
  */
 template <typename Vec, typename Vec_scalar = scalar_type_t<Vec>,
-          require_std_vector_vt<std::is_arithmetic, Vec>...>
+          require_std_vector_vt<std::is_arithmetic, Vec>* = nullptr>
 inline matrix_cl<Vec_scalar> to_matrix_cl(Vec&& src) {
   return matrix_cl<Vec_scalar>(std::forward<Vec>(src));
 }
@@ -158,7 +158,7 @@ inline std::vector<T> packed_copy(const matrix_cl<T>& src) {
  */
 template <matrix_cl_view matrix_view, typename Vec,
           typename Vec_scalar = scalar_type_t<Vec>,
-          require_vector_vt<std::is_arithmetic, Vec>...>
+          require_vector_vt<std::is_arithmetic, Vec>* = nullptr>
 inline matrix_cl<Vec_scalar> packed_copy(Vec&& src, int rows) {
   const int packed_size = rows * (rows + 1) / 2;
   check_size_match("copy (packed std::vector -> OpenCL)", "src.size()",

stan/math/opencl/kernel_cl.hpp

@@ -112,7 +112,7 @@ inline void assign_event(const cl::Event& e,
   helper.set(e, m);
 }
 
-template <typename T, require_same_t<T, cl::Event>...>
+template <typename T, require_same_t<T, cl::Event>* = nullptr>
 inline void assign_events(const T&) {}
 
 /** \ingroup kernel_executor_opencl

stan/math/opencl/kernel_generator/as_operation_cl.hpp

@@ -38,11 +38,21 @@ inline T_operation&& as_operation_cl(T_operation&& a) {
  * @param a scalar
  * @return \c scalar_ wrapping the input
  */
-template <typename T_scalar, typename = require_arithmetic_t<T_scalar>>
+template <typename T_scalar, typename = require_arithmetic_t<T_scalar>,
+          require_not_same_t<T_scalar, bool>* = nullptr>
 inline scalar_<T_scalar> as_operation_cl(const T_scalar a) {
   return scalar_<T_scalar>(a);
 }
 
+/**
+ * Converts any valid kernel generator expression into an operation. This is an
+ * overload for bool scalars. It wraps them into \c scalar_<char> as \c bool can
+ * not be used as a type of a kernel argument.
+ * @param a scalar
+ * @return \c scalar_<char> wrapping the input
+ */
+inline scalar_<char> as_operation_cl(const bool a) { return scalar_<char>(a); }
+
 /**
  * Converts any valid kernel generator expression into an operation. This is an
  * overload for \c matrix_cl. It wraps them into into \c load_.

stan/math/opencl/kernel_generator/holder_cl.hpp

@@ -74,35 +74,6 @@ auto holder_cl(T&& a, Ptrs*... ptrs) {
 }
 
 namespace internal {
-/**
- * Handles single element (moving rvalues to heap) for construction of
- * `holder_cl` from a functor. For lvalues just sets the `res` pointer.
- * @tparam T type of the element
- * @param a element to handle
- * @param res resulting pointer to element
- * @return tuple of pointer allocated on heap (empty).
- */
-template <typename T>
-auto holder_cl_handle_element(const T& a, const T*& res) {
-  res = &a;
-  return std::make_tuple();
-}
-
-/**
- * Handles single element (moving rvalues to heap) for construction of
- * `holder_cl` from a functor. Rvalue is moved to heap and the pointer to heap
- * memory is assigned to res and returned in a tuple.
- * @tparam T type of the element
- * @param a element to handle
- * @param res resulting pointer to element
- * @return tuple of pointer allocated on heap (containing single pointer).
- */
-template <typename T>
-auto holder_cl_handle_element(std::remove_reference_t<T>&& a, const T*& res) {
-  res = new T(std::move(a));
-  return std::make_tuple(res);
-}
-
 /**
  * Second step in implementation of construction `holder_cl` from a functor.
  * @tparam T type of the result expression
@@ -114,8 +85,8 @@ auto holder_cl_handle_element(std::remove_reference_t<T>&& a, const T*& res) {
  * @return `holder_cl` referencing given expression
  */
 template <typename T, std::size_t... Is, typename... Args>
-auto make_holder_cl_impl2(T&& expr, std::index_sequence<Is...>,
-                          const std::tuple<Args*...>& ptrs) {
+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)...);
 }
 
@@ -129,12 +100,12 @@ auto make_holder_cl_impl2(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(const T& func, std::index_sequence<Is...>,
-                         Args&&... args) {
-  std::tuple<const std::remove_reference_t<Args>*...> res;
+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_cl_handle_element(std::forward<Args>(args), std::get<Is>(res))...);
-  return make_holder_cl_impl2(
+      holder_handle_element(std::forward<Args>(args), std::get<Is>(res))...);
+  return make_holder_cl_impl_step2(
       func(*std::get<Is>(res)...),
       std::make_index_sequence<std::tuple_size<decltype(ptrs)>::value>(), ptrs);
 }
@@ -156,7 +127,7 @@ template <typename T, typename... Args,
               decltype(std::declval<T>()(std::declval<Args&>()...)),
               Args...>* = nullptr>
 auto make_holder_cl(const T& func, Args&&... args) {
-  return internal::make_holder_cl_impl(
+  return internal::make_holder_cl_impl_step1(
       func, std::make_index_sequence<sizeof...(Args)>(),
       std::forward<Args>(args)...);
 }

stan/math/opencl/kernel_generator/type_str.hpp

@@ -23,6 +23,7 @@ inline std::string type_str() {
   }
 ADD_TYPE_TO_TYPE_STR(double)
 ADD_TYPE_TO_TYPE_STR(int)
+ADD_TYPE_TO_TYPE_STR(char)
 ADD_TYPE_TO_TYPE_STR(bool)
 #undef ADD_TYPE_TO_TYPE_STR
 /** @}*/