Merge pull request #2822 from Franzi2114/feature/issue-2682-Add-7-par…

…ameter-DDM-PDF

Feature/issue 2682 add 7 parameter ddm pdf

stan/math/prim/functor/apply.hpp

@@ -10,20 +10,26 @@ namespace math {
 namespace internal {
 /*
  * Invoke the functor f with arguments given in t and indexed in the index
- * sequence I
+ * sequence I with other arguments possibly before or after
  *
  * @tparam F Type of functor
  * @tparam Tuple Type of tuple containing arguments
+ * @tparam PreArgs Parameter pack of arguments before the tuple
  * @tparam I Parameter pack of an index sequence going from 0 to
  * std::tuple_size<T>::value - 1 inclusive
  * @param f functor callable
  * @param t tuple of arguments
  * @param i placeholder variable for index sequence
+ * @param pre_args parameter pack of arguments to place before elements in
+ * tuple.
  */
-template <class F, class Tuple, std::size_t... I>
+template <class F, class Tuple, typename... PreArgs, std::size_t... I>
 constexpr decltype(auto) apply_impl(F&& f, Tuple&& t,
-                                    std::index_sequence<I...> i) {
-  return f(std::forward<decltype(std::get<I>(t))>(std::get<I>(t))...);
+                                    std::index_sequence<I...> i,
+                                    PreArgs&&... pre_args) {
+  return std::forward<F>(f)(
+      std::forward<PreArgs>(pre_args)...,
+      std::forward<decltype(std::get<I>(t))>(std::get<I>(t))...);
 }
 }  // namespace internal
 
@@ -36,15 +42,19 @@ constexpr decltype(auto) apply_impl(F&& f, Tuple&& t,
  *
  * @tparam F Type of functor
  * @tparam Tuple Type of tuple containing arguments
+ * @tparam PreArgs Parameter pack of arguments before the tuple
  * @param f functor callable
  * @param t tuple of arguments
+ * @param pre_args parameter pack of arguments to place before elements in
+ * tuple.
  */
-template <class F, class Tuple>
-constexpr decltype(auto) apply(F&& f, Tuple&& t) {
+template <class F, class Tuple, typename... PreArgs>
+constexpr decltype(auto) apply(F&& f, Tuple&& t, PreArgs&&... pre_args) {
   return internal::apply_impl(
       std::forward<F>(f), std::forward<Tuple>(t),
       std::make_index_sequence<
-          std::tuple_size<std::remove_reference_t<Tuple>>{}>{});
+          std::tuple_size<std::remove_reference_t<Tuple>>{}>{},
+      std::forward<PreArgs>(pre_args)...);
 }
 
 }  // namespace math