Feature/issue 2682 add 7 parameter ddm pdf

Jenkinsfile

@@ -142,11 +142,11 @@ pipeline {
             }
             post {
                 always {
-                    recordIssues enabledForFailure: true, tools:
-                        [cppLint(),
-                         groovyScript(parserId: 'mathDependencies', pattern: '**/dependencies.log')]
+                    recordIssues( 
+                        enabledForFailure: true, 
+                        tools: [cppLint(),groovyScript(parserId: 'mathDependencies', pattern: '**/dependencies.log')]
+                    )
                     deleteDir()
-
                 }
             }
         }
@@ -574,7 +574,10 @@ pipeline {
     post {
         always {
             node("linux") {
-                recordIssues enabledForFailure: false, tool: clang()
+                recordIssues(
+                    enabledForFailure: false, 
+                    tool: clang()
+                )
             }
         }
         success {

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