From 8099c90fb61dd96326be00be969fe5ceb520504c Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Mon, 30 Dec 2019 17:27:05 +0100
Subject: [PATCH 001/189] prim version

---
 stan/math/prim/scal.hpp                       |  2 +
 .../prim/scal/functor/parallel_reduce_sum.hpp | 79 +++++++++++++++++++
 .../functor/parallel_v3_reduce_sum_test.cpp   | 69 ++++++++++++++++
 3 files changed, 150 insertions(+)
 create mode 100644 stan/math/prim/scal/functor/parallel_reduce_sum.hpp
 create mode 100644 test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp

diff --git a/stan/math/prim/scal.hpp b/stan/math/prim/scal.hpp
index 1784f714688..ea4700b4722 100644
--- a/stan/math/prim/scal.hpp
+++ b/stan/math/prim/scal.hpp
@@ -131,6 +131,8 @@
 #include <stan/math/prim/scal/fun/value_of.hpp>
 #include <stan/math/prim/scal/fun/value_of_rec.hpp>
 
+#include <stan/math/prim/scal/functor/parallel_reduce_sum.hpp>
+
 #include <stan/math/prim/scal/prob/bernoulli_ccdf_log.hpp>
 #include <stan/math/prim/scal/prob/bernoulli_cdf.hpp>
 #include <stan/math/prim/scal/prob/bernoulli_cdf_log.hpp>
diff --git a/stan/math/prim/scal/functor/parallel_reduce_sum.hpp b/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
new file mode 100644
index 00000000000..4a00db87de7
--- /dev/null
+++ b/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
@@ -0,0 +1,79 @@
+#ifndef STAN_MATH_PRIM_SCAL_FUNCTOR_PARALLEL_REDUCE_SUM_HPP
+#define STAN_MATH_PRIM_SCAL_FUNCTOR_PARALLEL_REDUCE_SUM_HPP
+
+#include <stan/math/prim/meta/return_type.hpp>
+#include <stan/math/prim/mat/fun/typedefs.hpp>
+
+#include <boost/iterator/counting_iterator.hpp>
+
+#include <tbb/task_arena.h>
+#include <tbb/parallel_reduce.h>
+#include <tbb/blocked_range.h>
+
+#include <iostream>
+#include <iterator>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+namespace internal {
+
+// base definition => compile error
+template <class ReduceFunction, class InputIt, class T, class T_return_type>
+struct parallel_reduce_sum_impl {};
+
+template <class ReduceFunction, class InputIt, class T>
+struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, double> {
+  struct recursive_reducer {
+    InputIt first_;
+    const T& init_;
+    T sum_;
+    typedef typename std::iterator_traits<InputIt>::value_type elem_t;
+
+    recursive_reducer(InputIt first, const T& init)
+        : first_(first), init_(init), sum_(init) {}
+
+    recursive_reducer(recursive_reducer& other, tbb::split)
+        : first_(other.first_), init_(other.init_), sum_(init_) {}
+
+    void operator()(const tbb::blocked_range<size_t>& r) {
+      if (r.empty())
+        return;
+
+      auto start = first_;
+      std::advance(start, r.begin());
+      auto end = first_;
+      std::advance(end, r.end());
+
+      std::vector<elem_t> sub_slice(start, end);
+
+      sum_ += ReduceFunction()(r.begin(), r.end() - 1, sub_slice);
+    }
+    void join(const recursive_reducer& child) { sum_ += child.sum_; }
+  };
+
+  T operator()(InputIt first, InputIt last, T init,
+               std::size_t grainsize) const {
+    const std::size_t num_jobs = std::distance(first, last);
+    recursive_reducer worker(first, init);
+    tbb::parallel_reduce(
+        tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
+    return std::move(worker.sum_);
+  }
+};
+}  // namespace internal
+
+template <class ReduceFunction, class InputIt, class T>
+constexpr T parallel_reduce_sum(InputIt first, InputIt last, T init,
+                                std::size_t grainsize = 1) {
+  typedef T return_base_t;
+  return internal::parallel_reduce_sum_impl<ReduceFunction, InputIt, T,
+                                            return_base_t>()(first, last, init,
+                                                             grainsize);
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
new file mode 100644
index 00000000000..d7e1e3f4eca
--- /dev/null
+++ b/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
@@ -0,0 +1,69 @@
+#include <stan/math.hpp>
+#include <gtest/gtest.h>
+#include <algorithm>
+#include <sstream>
+#include <tuple>
+#include <vector>
+
+// reduce functor which is the BinaryFunction
+// here we use iterators which represent integer indices
+template <typename T>
+struct count_lpdf {
+  count_lpdf() {}
+
+  // does the reduction in the sub-slice start to end
+  inline T operator()(std::size_t start, std::size_t end,
+                      std::vector<int> sub_slice) const {
+    T lambda = 10.0;
+    return stan::math::poisson_lpmf(sub_slice, lambda);
+  }
+};
+
+TEST(parallel_v3_reduce_sum, gradient) {
+  double lambda_d = 10.0;
+  const std::size_t elems = 10000;
+  const std::size_t num_iter = 1000;
+  std::vector<int> data(elems);
+
+  for (std::size_t i = 0; i != elems; ++i)
+    data[i] = i;
+
+  typedef boost::counting_iterator<std::size_t> count_iter;
+
+  double poisson_lpdf = stan::math::parallel_reduce_sum<count_lpdf<double>>(
+      data.begin(), data.end(), 0.0);
+
+  double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
+
+  EXPECT_FLOAT_EQ(poisson_lpdf, poisson_lpdf_ref);
+}
+
+/*
+TEST(parallel_v3_reduce_sum, gradient) {
+  double lambda_d = 10.0;
+  const std::size_t elems = 10000;
+  const std::size_t num_iter = 1000;
+  std::vector<int> data(elems);
+
+  for (std::size_t i = 0; i != elems; ++i)
+    data[i] = i;
+
+  typedef boost::counting_iterator<std::size_t> count_iter;
+  using stan::math::var;
+
+  count_lpdf<double> reduce_op;
+
+  var poisson_lpdf = stan::math::parallel_reduce_sum(
+      count_iter(0), count_iter(elems), var(0.0), reduce_op);
+
+  var lambda_ref = lambda_d;
+  var poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_ref);
+
+  EXPECT_FLOAT_EQ(value_of(poisson_lpdf), value_of(poisson_lpdf_ref));
+
+  stan::math::grad(poisson_lpdf.vi_);
+  stan::math::grad(poisson_lpdf_ref.vi_);
+
+  EXPECT_FLOAT_EQ(poisson_lpdf.adj(), poisson_lpdf_ref.adj());
+}
+*/

From 7027c12b6b888948168c46039aad029ce67c165b Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Mon, 30 Dec 2019 19:35:05 +0100
Subject: [PATCH 002/189] make nested stuff work

---
 .../prim/scal/functor/parallel_reduce_sum.hpp |  33 +++---
 stan/math/rev/scal.hpp                        |   2 +
 .../rev/scal/functor/parallel_reduce_sum.hpp  | 107 ++++++++++++++++++
 .../functor/parallel_v3_reduce_sum_test.cpp   |  39 +++++--
 4 files changed, 156 insertions(+), 25 deletions(-)
 create mode 100644 stan/math/rev/scal/functor/parallel_reduce_sum.hpp

diff --git a/stan/math/prim/scal/functor/parallel_reduce_sum.hpp b/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
index 4a00db87de7..50bca41c251 100644
--- a/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
@@ -20,22 +20,27 @@ namespace math {
 namespace internal {
 
 // base definition => compile error
-template <class ReduceFunction, class InputIt, class T, class T_return_type>
+template <class ReduceFunction, class InputIt, class T, class Arg1,
+          class T_return_type>
 struct parallel_reduce_sum_impl {};
 
-template <class ReduceFunction, class InputIt, class T>
-struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, double> {
+template <class ReduceFunction, class InputIt, class T, class Arg1>
+struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, double> {
   struct recursive_reducer {
     InputIt first_;
     const T& init_;
+    Arg1& arg1_;
     T sum_;
     typedef typename std::iterator_traits<InputIt>::value_type elem_t;
 
-    recursive_reducer(InputIt first, const T& init)
-        : first_(first), init_(init), sum_(init) {}
+    recursive_reducer(InputIt first, const T& init, Arg1& arg1)
+        : first_(first), init_(init), arg1_(arg1), sum_(init) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-        : first_(other.first_), init_(other.init_), sum_(init_) {}
+        : first_(other.first_),
+          init_(other.init_),
+          arg1_(other.arg1_),
+          sum_(init_) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty())
@@ -48,15 +53,15 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, double> {
 
       std::vector<elem_t> sub_slice(start, end);
 
-      sum_ += ReduceFunction()(r.begin(), r.end() - 1, sub_slice);
+      sum_ += ReduceFunction()(r.begin(), r.end() - 1, sub_slice, arg1_);
     }
     void join(const recursive_reducer& child) { sum_ += child.sum_; }
   };
 
-  T operator()(InputIt first, InputIt last, T init,
-               std::size_t grainsize) const {
+  T operator()(InputIt first, InputIt last, T init, std::size_t grainsize,
+               Arg1& arg1) const {
     const std::size_t num_jobs = std::distance(first, last);
-    recursive_reducer worker(first, init);
+    recursive_reducer worker(first, init, arg1);
     tbb::parallel_reduce(
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
     return std::move(worker.sum_);
@@ -64,13 +69,13 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, double> {
 };
 }  // namespace internal
 
-template <class ReduceFunction, class InputIt, class T>
+template <class ReduceFunction, class InputIt, class T, class Arg1>
 constexpr T parallel_reduce_sum(InputIt first, InputIt last, T init,
-                                std::size_t grainsize = 1) {
+                                std::size_t grainsize, Arg1& arg1) {
   typedef T return_base_t;
-  return internal::parallel_reduce_sum_impl<ReduceFunction, InputIt, T,
+  return internal::parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1,
                                             return_base_t>()(first, last, init,
-                                                             grainsize);
+                                                             grainsize, arg1);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/scal.hpp b/stan/math/rev/scal.hpp
index ff4a91c1f79..2ac1387a702 100644
--- a/stan/math/rev/scal.hpp
+++ b/stan/math/rev/scal.hpp
@@ -102,4 +102,6 @@
 #include <stan/math/rev/scal/fun/value_of.hpp>
 #include <stan/math/rev/scal/fun/value_of_rec.hpp>
 
+#include <stan/math/rev/scal/functor/parallel_reduce_sum.hpp>
+
 #endif
diff --git a/stan/math/rev/scal/functor/parallel_reduce_sum.hpp b/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
new file mode 100644
index 00000000000..7bf2a7b3db9
--- /dev/null
+++ b/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
@@ -0,0 +1,107 @@
+#ifndef STAN_MATH_REV_SCAL_FUNCTOR_PARALLEL_REDUCE_SUM_HPP
+#define STAN_MATH_REV_SCAL_FUNCTOR_PARALLEL_REDUCE_SUM_HPP
+
+#include <stan/math/prim/meta/return_type.hpp>
+#include <stan/math/rev/mat/fun/typedefs.hpp>
+
+#include <boost/iterator/counting_iterator.hpp>
+
+#include <tbb/task_arena.h>
+#include <tbb/parallel_reduce.h>
+#include <tbb/blocked_range.h>
+
+#include <iostream>
+#include <iterator>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+namespace internal {
+
+template <class ReduceFunction, class InputIt, class T, class Arg1>
+struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
+  using ops_partials_t = operands_and_partials<Arg1>;
+
+  struct recursive_reducer {
+    InputIt first_;
+    const T& init_;
+    Arg1& arg1_;
+    std::vector<double> terms_adjs_;
+    std::vector<double> terms_vals_;
+    typedef typename std::iterator_traits<InputIt>::value_type elem_t;
+
+    recursive_reducer(InputIt first, const T& init, Arg1& arg1)
+        : first_(first),
+          init_(init),
+          arg1_(arg1),
+          terms_adjs_(1, 0.0),
+          terms_vals_(1, init_.val()) {}
+
+    recursive_reducer(recursive_reducer& other, tbb::split)
+        : first_(other.first_),
+          init_(other.init_),
+          arg1_(other.arg1_),
+          terms_adjs_(1, 0.0),
+          terms_vals_(1, init_.val()) {}
+    // terms_adjs_(other.terms_adjs_), terms_vals_(other.terms_vals_) {}
+
+    void operator()(const tbb::blocked_range<size_t>& r) {
+      if (r.empty())
+        return;
+
+      auto start = first_;
+      std::advance(start, r.begin());
+      auto end = first_;
+      std::advance(end, r.end());
+
+      try {
+        start_nested();
+
+        // elem_t should better be a non-var!!! Otherwise we interfere
+        // with the outer AD tree as we mess with the adjoints (and
+        // right now we discard that it is a var if it would be)
+        std::vector<elem_t> sub_slice(start, end);
+
+        // create a copy of arg1 which is not tied to the out AD tree
+        Arg1 arg1(var(new vari(arg1_.val(), false)));
+
+        T sub_sum_v = ReduceFunction()(r.begin(), r.end() - 1, sub_slice, arg1);
+
+        sub_sum_v.grad();
+
+        terms_vals_.push_back(sub_sum_v.val());
+        terms_adjs_.push_back(arg1.adj());
+
+      } catch (const std::exception& e) {
+        recover_memory_nested();
+        throw;
+      }
+      recover_memory_nested();
+    }
+    void join(const recursive_reducer& child) {
+      terms_adjs_.insert(terms_adjs_.end(), child.terms_adjs_.begin(),
+                         child.terms_adjs_.end());
+      terms_vals_.insert(terms_vals_.end(), child.terms_vals_.begin(),
+                         child.terms_vals_.end());
+    }
+  };
+
+  T operator()(InputIt first, InputIt last, T init, std::size_t grainsize,
+               Arg1& arg1) const {
+    const std::size_t num_jobs = std::distance(first, last);
+    recursive_reducer worker(first, init, arg1);
+    tbb::parallel_reduce(
+        tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
+    std::vector<T> terms(worker.terms_adjs_.size());
+    ops_partials_t ops_sum(arg1);
+    ops_sum.edge1_.partials_[0] = sum(worker.terms_adjs_);
+    return ops_sum.build(sum(worker.terms_vals_));
+  }
+};
+}  // namespace internal
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
index d7e1e3f4eca..6e9824cf989 100644
--- a/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
@@ -1,3 +1,4 @@
+#include <stan/math/prim/core/init_threadpool_tbb.hpp>
 #include <stan/math.hpp>
 #include <gtest/gtest.h>
 #include <algorithm>
@@ -13,13 +14,14 @@ struct count_lpdf {
 
   // does the reduction in the sub-slice start to end
   inline T operator()(std::size_t start, std::size_t end,
-                      std::vector<int> sub_slice) const {
-    T lambda = 10.0;
+                      std::vector<int> sub_slice, T& lambda) const {
     return stan::math::poisson_lpmf(sub_slice, lambda);
   }
 };
 
-TEST(parallel_v3_reduce_sum, gradient) {
+TEST(parallel_v3_reduce_sum, value) {
+  stan::math::init_threadpool_tbb();
+
   double lambda_d = 10.0;
   const std::size_t elems = 10000;
   const std::size_t num_iter = 1000;
@@ -31,15 +33,16 @@ TEST(parallel_v3_reduce_sum, gradient) {
   typedef boost::counting_iterator<std::size_t> count_iter;
 
   double poisson_lpdf = stan::math::parallel_reduce_sum<count_lpdf<double>>(
-      data.begin(), data.end(), 0.0);
+      data.begin(), data.end(), 0.0, 5, lambda_d);
 
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
 
   EXPECT_FLOAT_EQ(poisson_lpdf, poisson_lpdf_ref);
 }
 
-/*
 TEST(parallel_v3_reduce_sum, gradient) {
+  stan::math::init_threadpool_tbb();
+
   double lambda_d = 10.0;
   const std::size_t elems = 10000;
   const std::size_t num_iter = 1000;
@@ -51,19 +54,33 @@ TEST(parallel_v3_reduce_sum, gradient) {
   typedef boost::counting_iterator<std::size_t> count_iter;
   using stan::math::var;
 
-  count_lpdf<double> reduce_op;
+  var lambda_v = lambda_d;
 
-  var poisson_lpdf = stan::math::parallel_reduce_sum(
-      count_iter(0), count_iter(elems), var(0.0), reduce_op);
+  var poisson_lpdf = stan::math::parallel_reduce_sum<count_lpdf<var>>(
+      data.begin(), data.end(), var(0.0), 5, lambda_v);
 
   var lambda_ref = lambda_d;
   var poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_ref);
 
   EXPECT_FLOAT_EQ(value_of(poisson_lpdf), value_of(poisson_lpdf_ref));
 
-  stan::math::grad(poisson_lpdf.vi_);
   stan::math::grad(poisson_lpdf_ref.vi_);
+  const double lambda_ref_adj = lambda_ref.adj();
+
+  stan::math::set_zero_all_adjoints();
+  stan::math::grad(poisson_lpdf.vi_);
+  const double lambda_adj = lambda_v.adj();
+
+  EXPECT_FLOAT_EQ(lambda_adj, lambda_ref_adj);
+
+  std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref.val()
+            << std::endl;
+  ;
+  std::cout << "ref gradient wrt to lambda: " << lambda_ref_adj << std::endl;
+  ;
 
-  EXPECT_FLOAT_EQ(poisson_lpdf.adj(), poisson_lpdf_ref.adj());
+  std::cout << "value of poisson lpdf : " << poisson_lpdf.val() << std::endl;
+  ;
+  std::cout << "gradient wrt to lambda: " << lambda_adj << std::endl;
+  ;
 }
-*/

From 302cd71850cb29f1de585e0a53a4f5cb100f0e42 Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Tue, 31 Dec 2019 10:29:54 +0100
Subject: [PATCH 003/189] extend signature and test nested parallel AD

---
 .../prim/scal/functor/parallel_reduce_sum.hpp |  30 +++--
 .../rev/scal/functor/parallel_reduce_sum.hpp  |  61 +++++----
 .../functor/parallel_v3_reduce_sum_test.cpp   | 119 +++++++++++++++++-
 3 files changed, 170 insertions(+), 40 deletions(-)

diff --git a/stan/math/prim/scal/functor/parallel_reduce_sum.hpp b/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
index 50bca41c251..6b613132012 100644
--- a/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
@@ -28,19 +28,20 @@ template <class ReduceFunction, class InputIt, class T, class Arg1>
 struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, double> {
   struct recursive_reducer {
     InputIt first_;
-    const T& init_;
-    Arg1& arg1_;
+    std::vector<Arg1>& varg1_;
+    const std::vector<int>& idata1_;
     T sum_;
     typedef typename std::iterator_traits<InputIt>::value_type elem_t;
 
-    recursive_reducer(InputIt first, const T& init, Arg1& arg1)
-        : first_(first), init_(init), arg1_(arg1), sum_(init) {}
+    recursive_reducer(InputIt first, const T& init, std::vector<Arg1>& varg1,
+                      const std::vector<int>& idata1)
+        : first_(first), varg1_(varg1), idata1_(idata1), sum_(init) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
         : first_(other.first_),
-          init_(other.init_),
-          arg1_(other.arg1_),
-          sum_(init_) {}
+          varg1_(other.varg1_),
+          idata1_(other.idata1_),
+          sum_(T(0.0)) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty())
@@ -53,15 +54,17 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, double> {
 
       std::vector<elem_t> sub_slice(start, end);
 
-      sum_ += ReduceFunction()(r.begin(), r.end() - 1, sub_slice, arg1_);
+      sum_ += ReduceFunction()(r.begin(), r.end() - 1, sub_slice, varg1_,
+                               idata1_);
     }
+
     void join(const recursive_reducer& child) { sum_ += child.sum_; }
   };
 
   T operator()(InputIt first, InputIt last, T init, std::size_t grainsize,
-               Arg1& arg1) const {
+               std::vector<Arg1>& varg1, const std::vector<int>& idata1) const {
     const std::size_t num_jobs = std::distance(first, last);
-    recursive_reducer worker(first, init, arg1);
+    recursive_reducer worker(first, init, varg1, idata1);
     tbb::parallel_reduce(
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
     return std::move(worker.sum_);
@@ -71,11 +74,12 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, double> {
 
 template <class ReduceFunction, class InputIt, class T, class Arg1>
 constexpr T parallel_reduce_sum(InputIt first, InputIt last, T init,
-                                std::size_t grainsize, Arg1& arg1) {
+                                std::size_t grainsize, std::vector<Arg1>& varg1,
+                                const std::vector<int>& idata1) {
   typedef T return_base_t;
   return internal::parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1,
-                                            return_base_t>()(first, last, init,
-                                                             grainsize, arg1);
+                                            return_base_t>()(
+      first, last, init, grainsize, varg1, idata1);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/scal/functor/parallel_reduce_sum.hpp b/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
index 7bf2a7b3db9..c0f22dd6ea0 100644
--- a/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
+++ b/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
@@ -21,29 +21,30 @@ namespace internal {
 
 template <class ReduceFunction, class InputIt, class T, class Arg1>
 struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
-  using ops_partials_t = operands_and_partials<Arg1>;
+  using ops_partials_t = operands_and_partials<std::vector<Arg1>>;
 
   struct recursive_reducer {
     InputIt first_;
-    const T& init_;
-    Arg1& arg1_;
-    std::vector<double> terms_adjs_;
+    std::vector<Arg1>& varg1_;
+    const std::vector<int>& idata1_;
+    std::vector<std::vector<double>> terms_adjs_;
     std::vector<double> terms_vals_;
     typedef typename std::iterator_traits<InputIt>::value_type elem_t;
 
-    recursive_reducer(InputIt first, const T& init, Arg1& arg1)
+    recursive_reducer(InputIt first, const T& init, std::vector<Arg1>& varg1,
+                      const std::vector<int>& idata1)
         : first_(first),
-          init_(init),
-          arg1_(arg1),
-          terms_adjs_(1, 0.0),
-          terms_vals_(1, init_.val()) {}
+          varg1_(varg1),
+          idata1_(idata1),
+          terms_adjs_(1, std::vector<double>(varg1.size(), 0.0)),
+          terms_vals_(1, init.val()) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
         : first_(other.first_),
-          init_(other.init_),
-          arg1_(other.arg1_),
-          terms_adjs_(1, 0.0),
-          terms_vals_(1, init_.val()) {}
+          varg1_(other.varg1_),
+          idata1_(other.idata1_),
+          terms_adjs_(),
+          terms_vals_() {}
     // terms_adjs_(other.terms_adjs_), terms_vals_(other.terms_vals_) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
@@ -63,15 +64,25 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
         // right now we discard that it is a var if it would be)
         std::vector<elem_t> sub_slice(start, end);
 
-        // create a copy of arg1 which is not tied to the out AD tree
-        Arg1 arg1(var(new vari(arg1_.val(), false)));
+        // create a deep copy of arg1 which is not tied to the outer AD tree
+        std::vector<Arg1> varg1;
+        varg1.reserve(varg1_.size());
 
-        T sub_sum_v = ReduceFunction()(r.begin(), r.end() - 1, sub_slice, arg1);
+        for (Arg1& elem : varg1_)
+          varg1.emplace_back(var(new vari(elem.val(), false)));
+
+        T sub_sum_v = ReduceFunction()(r.begin(), r.end() - 1, sub_slice, varg1,
+                                       idata1_);
 
         sub_sum_v.grad();
 
         terms_vals_.push_back(sub_sum_v.val());
-        terms_adjs_.push_back(arg1.adj());
+
+        std::vector<double> varg1_adj;
+        for (const Arg1& elem : varg1)
+          varg1_adj.push_back(elem.adj());
+
+        terms_adjs_.push_back(varg1_adj);
 
       } catch (const std::exception& e) {
         recover_memory_nested();
@@ -88,15 +99,19 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
   };
 
   T operator()(InputIt first, InputIt last, T init, std::size_t grainsize,
-               Arg1& arg1) const {
+               std::vector<Arg1>& varg1, const std::vector<int>& idata) const {
     const std::size_t num_jobs = std::distance(first, last);
-    recursive_reducer worker(first, init, arg1);
+    recursive_reducer worker(first, init, varg1, idata);
     tbb::parallel_reduce(
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
-    std::vector<T> terms(worker.terms_adjs_.size());
-    ops_partials_t ops_sum(arg1);
-    ops_sum.edge1_.partials_[0] = sum(worker.terms_adjs_);
-    return ops_sum.build(sum(worker.terms_vals_));
+    ops_partials_t ops_sum(varg1);
+    double sum = 0.0;
+    for (std::size_t i = 0; i != worker.terms_adjs_.size(); ++i) {
+      sum += worker.terms_vals_[i];
+      for (std::size_t j = 0; j != worker.terms_adjs_[i].size(); ++j)
+        ops_sum.edge1_.partials_[j] += worker.terms_adjs_[i][j];
+    }
+    return ops_sum.build(sum);
   }
 };
 }  // namespace internal
diff --git a/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
index 6e9824cf989..51ae3a1a0d3 100644
--- a/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
@@ -14,8 +14,9 @@ struct count_lpdf {
 
   // does the reduction in the sub-slice start to end
   inline T operator()(std::size_t start, std::size_t end,
-                      std::vector<int> sub_slice, T& lambda) const {
-    return stan::math::poisson_lpmf(sub_slice, lambda);
+                      std::vector<int>& sub_slice, std::vector<T>& lambda,
+                      const std::vector<int>& idata) const {
+    return stan::math::poisson_lpmf(sub_slice, lambda[0]);
   }
 };
 
@@ -30,14 +31,23 @@ TEST(parallel_v3_reduce_sum, value) {
   for (std::size_t i = 0; i != elems; ++i)
     data[i] = i;
 
+  std::vector<int> idata;
+  std::vector<double> vlambda_d(1, lambda_d);
+
   typedef boost::counting_iterator<std::size_t> count_iter;
 
   double poisson_lpdf = stan::math::parallel_reduce_sum<count_lpdf<double>>(
-      data.begin(), data.end(), 0.0, 5, lambda_d);
+      data.begin(), data.end(), 0.0, 5, vlambda_d, idata);
 
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
 
   EXPECT_FLOAT_EQ(poisson_lpdf, poisson_lpdf_ref);
+
+  std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref << std::endl;
+  ;
+
+  std::cout << "value of poisson lpdf : " << poisson_lpdf << std::endl;
+  ;
 }
 
 TEST(parallel_v3_reduce_sum, gradient) {
@@ -56,8 +66,107 @@ TEST(parallel_v3_reduce_sum, gradient) {
 
   var lambda_v = lambda_d;
 
+  std::vector<int> idata;
+  std::vector<var> vlambda_v(1, lambda_v);
+
   var poisson_lpdf = stan::math::parallel_reduce_sum<count_lpdf<var>>(
-      data.begin(), data.end(), var(0.0), 5, lambda_v);
+      data.begin(), data.end(), var(0.0), 5, vlambda_v, idata);
+
+  var lambda_ref = lambda_d;
+  var poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_ref);
+
+  EXPECT_FLOAT_EQ(value_of(poisson_lpdf), value_of(poisson_lpdf_ref));
+
+  stan::math::grad(poisson_lpdf_ref.vi_);
+  const double lambda_ref_adj = lambda_ref.adj();
+
+  stan::math::set_zero_all_adjoints();
+  stan::math::grad(poisson_lpdf.vi_);
+  const double lambda_adj = lambda_v.adj();
+
+  EXPECT_FLOAT_EQ(lambda_adj, lambda_ref_adj);
+
+  std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref.val()
+            << std::endl;
+  ;
+  std::cout << "ref gradient wrt to lambda: " << lambda_ref_adj << std::endl;
+  ;
+
+  std::cout << "value of poisson lpdf : " << poisson_lpdf.val() << std::endl;
+  ;
+  std::cout << "gradient wrt to lambda: " << lambda_adj << std::endl;
+  ;
+  stan::math::recover_memory();
+}
+
+// ********************************
+// test if nested parallelism works
+// ********************************
+
+template <typename T>
+struct nesting_count_lpdf {
+  nesting_count_lpdf() {}
+
+  // does the reduction in the sub-slice start to end
+  inline T operator()(std::size_t start, std::size_t end,
+                      std::vector<int>& sub_slice, std::vector<T>& lambda,
+                      const std::vector<int>& idata) const {
+    return stan::math::parallel_reduce_sum<count_lpdf<T>>(
+        sub_slice.begin(), sub_slice.end(), T(0.0), 5, lambda, idata);
+  }
+};
+
+TEST(parallel_v3_reduce_sum, nesting_value) {
+  stan::math::init_threadpool_tbb();
+
+  double lambda_d = 10.0;
+  const std::size_t elems = 10000;
+  const std::size_t num_iter = 1000;
+  std::vector<int> data(elems);
+
+  for (std::size_t i = 0; i != elems; ++i)
+    data[i] = i;
+
+  std::vector<int> idata;
+  std::vector<double> vlambda_d(1, lambda_d);
+
+  typedef boost::counting_iterator<std::size_t> count_iter;
+
+  double poisson_lpdf = stan::math::parallel_reduce_sum<count_lpdf<double>>(
+      data.begin(), data.end(), 0.0, 5, vlambda_d, idata);
+
+  double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
+
+  EXPECT_FLOAT_EQ(poisson_lpdf, poisson_lpdf_ref);
+
+  std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref << std::endl;
+  ;
+
+  std::cout << "value of poisson lpdf : " << poisson_lpdf << std::endl;
+  ;
+}
+
+TEST(parallel_v3_reduce_sum, nesting_gradient) {
+  stan::math::init_threadpool_tbb();
+
+  double lambda_d = 10.0;
+  const std::size_t elems = 10000;
+  const std::size_t num_iter = 1000;
+  std::vector<int> data(elems);
+
+  for (std::size_t i = 0; i != elems; ++i)
+    data[i] = i;
+
+  typedef boost::counting_iterator<std::size_t> count_iter;
+  using stan::math::var;
+
+  var lambda_v = lambda_d;
+
+  std::vector<int> idata;
+  std::vector<var> vlambda_v(1, lambda_v);
+
+  var poisson_lpdf = stan::math::parallel_reduce_sum<nesting_count_lpdf<var>>(
+      data.begin(), data.end(), var(0.0), 5, vlambda_v, idata);
 
   var lambda_ref = lambda_d;
   var poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_ref);
@@ -83,4 +192,6 @@ TEST(parallel_v3_reduce_sum, gradient) {
   ;
   std::cout << "gradient wrt to lambda: " << lambda_adj << std::endl;
   ;
+
+  stan::math::recover_memory();
 }

From 9740b45928d07c6dbd13bf304d4ea22706f4cc4f Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Tue, 31 Dec 2019 11:12:59 +0100
Subject: [PATCH 004/189] add hierarchical example

---
 .../functor/parallel_v3_reduce_sum_test.cpp   | 83 +++++++++++++++++++
 1 file changed, 83 insertions(+)

diff --git a/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
index 51ae3a1a0d3..d9616dcc150 100644
--- a/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
@@ -195,3 +195,86 @@ TEST(parallel_v3_reduce_sum, nesting_gradient) {
 
   stan::math::recover_memory();
 }
+
+// ********************************
+// basic performance test for a hierarchical model
+// ********************************
+
+template <typename T>
+struct grouped_count_lpdf {
+  grouped_count_lpdf() {}
+
+  // does the reduction in the sub-slice start to end
+  inline T operator()(std::size_t start, std::size_t end,
+                      std::vector<int>& sub_slice, std::vector<T>& lambda,
+                      const std::vector<int>& gidx) const {
+    const std::size_t num_terms = end - start + 1;
+    // std::cout << "sub-slice " << start << " - " << end << "; num_terms = " <<
+    // num_terms << "; size = " << sub_slice.size() << std::endl;
+    std::vector<T> lambda_slice(num_terms, 0.0);
+    for (std::size_t i = 0; i != num_terms; ++i)
+      lambda_slice[i] = lambda[gidx[start + i]];
+    return stan::math::poisson_lpmf(sub_slice, lambda_slice);
+  }
+};
+
+TEST(parallel_v3_reduce_sum, grouped_gradient) {
+  stan::math::init_threadpool_tbb();
+
+  double lambda_d = 10.0;
+  const std::size_t groups = 10;
+  const std::size_t elems_per_group = 1000;
+  const std::size_t elems = groups * elems_per_group;
+  const std::size_t num_iter = 1000;
+
+  std::vector<int> data(elems);
+  std::vector<int> gidx(elems);
+
+  for (std::size_t i = 0; i != elems; ++i) {
+    data[i] = i;
+    gidx[i] = i / elems_per_group;
+  }
+
+  using stan::math::var;
+
+  std::vector<var> vlambda_v;
+
+  for (std::size_t i = 0; i != groups; ++i)
+    vlambda_v.push_back(i + 0.2);
+
+  var lambda_v = vlambda_v[0];
+
+  var poisson_lpdf = stan::math::parallel_reduce_sum<grouped_count_lpdf<var>>(
+      data.begin(), data.end(), var(0.0), 5, vlambda_v, gidx);
+
+  std::vector<var> vref_lambda_v;
+  for (std::size_t i = 0; i != elems; ++i) {
+    vref_lambda_v.push_back(vlambda_v[gidx[i]]);
+  }
+  var lambda_ref = vlambda_v[0];
+
+  var poisson_lpdf_ref = stan::math::poisson_lpmf(data, vref_lambda_v);
+
+  EXPECT_FLOAT_EQ(value_of(poisson_lpdf), value_of(poisson_lpdf_ref));
+
+  stan::math::grad(poisson_lpdf_ref.vi_);
+  const double lambda_ref_adj = lambda_ref.adj();
+
+  stan::math::set_zero_all_adjoints();
+  stan::math::grad(poisson_lpdf.vi_);
+  const double lambda_adj = lambda_v.adj();
+
+  EXPECT_FLOAT_EQ(lambda_adj, lambda_ref_adj);
+
+  std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref.val()
+            << std::endl;
+  ;
+  std::cout << "ref gradient wrt to lambda: " << lambda_ref_adj << std::endl;
+  ;
+
+  std::cout << "value of poisson lpdf : " << poisson_lpdf.val() << std::endl;
+  ;
+  std::cout << "gradient wrt to lambda: " << lambda_adj << std::endl;
+  ;
+  stan::math::recover_memory();
+}

From e47ca13518ddbff1f35dca1813a59f4f17dd5dae Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Tue, 31 Dec 2019 14:51:29 +0100
Subject: [PATCH 005/189] add recover_memory_global

---
 .../prim/scal/functor/parallel_reduce_sum.hpp | 40 +++++++++++++++++++
 stan/math/rev/core.hpp                        |  1 +
 stan/math/rev/core/init_chainablestack.hpp    |  7 ++--
 3 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/stan/math/prim/scal/functor/parallel_reduce_sum.hpp b/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
index 6b613132012..415b925f8cd 100644
--- a/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
@@ -72,6 +72,46 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, double> {
 };
 }  // namespace internal
 
+/*
+ * The ReduceFunction is expected to have an operator with the
+ * signature
+ *
+ * inline T operator()(std::size_t start, std::size_t end,
+ *                     std::vector<int>& sub_slice, std::vector<T>& lambda,
+ *                     const std::vector<int>& gidx) const
+ *
+ * So the input data is sliced into smaller pieces and given into the
+ * reducer. Which exact sub-slice is given to the function is defined
+ * by start and end index. These can be used to map data to groups,
+ * for example. It would be good to extend this signature in two ways:
+ *
+ * 1. The large std::vector which is sliced into smaller pieces should
+ *    be allowed to be any data (so int, double, vectors, matrices,
+ *    ...). In a second step this should also be extended to vars
+ *    which will require more considerations, but is beneficial. One
+ *    could leave this generalization to a future version.
+ *
+ * 2. The arguments past sub_slice should be variable. So the
+ *    arguments past sub_slice would need to be represented by the
+ *    "..." thing in C++. The complication for this is managing all
+ *    the calls.
+ *
+ * So the parallel_reduce_sum signature should look like
+ *
+ * template <class ReduceFunction, class InputIt, class T, ...>
+ * constexpr T parallel_reduce_sum(InputIt first, InputIt last, T init,
+ *                                std::size_t grainsize, ...)
+ *
+ * which corresponds to a ReduceFunction which looks like
+ *
+ * inline T operator()(std::size_t start, std::size_t end,
+ *                     std::vector<InputIt*>& sub_slice, ...)
+ *
+ * Note that the ReduceFunction is only passed in as type to prohibit
+ * that any internal state of the functor is causing trouble. Thus,
+ * the functor must be default constructible without any arguments.
+ *
+ */
 template <class ReduceFunction, class InputIt, class T, class Arg1>
 constexpr T parallel_reduce_sum(InputIt first, InputIt last, T init,
                                 std::size_t grainsize, std::vector<Arg1>& varg1,
diff --git a/stan/math/rev/core.hpp b/stan/math/rev/core.hpp
index db951f75576..b44f1cce469 100644
--- a/stan/math/rev/core.hpp
+++ b/stan/math/rev/core.hpp
@@ -43,6 +43,7 @@
 #include <stan/math/rev/core/print_stack.hpp>
 #include <stan/math/rev/core/recover_memory.hpp>
 #include <stan/math/rev/core/recover_memory_nested.hpp>
+#include <stan/math/rev/core/recover_memory_global.hpp>
 #include <stan/math/rev/core/set_zero_all_adjoints.hpp>
 #include <stan/math/rev/core/set_zero_all_adjoints_nested.hpp>
 #include <stan/math/rev/core/start_nested.hpp>
diff --git a/stan/math/rev/core/init_chainablestack.hpp b/stan/math/rev/core/init_chainablestack.hpp
index 8f1b903cc9e..54646d85d66 100644
--- a/stan/math/rev/core/init_chainablestack.hpp
+++ b/stan/math/rev/core/init_chainablestack.hpp
@@ -53,16 +53,15 @@ class ad_tape_observer : public tbb::task_scheduler_observer {
     }
   }
 
- private:
   ad_map thread_tape_map_;
   std::mutex thread_tape_map_mutex_;
 };
 
-namespace {
+namespace internal {
 
-ad_tape_observer global_observer;
+static ad_tape_observer global_observer;
 
-}  // namespace
+}  // namespace internal
 }  // namespace math
 }  // namespace stan
 

From 9565db93a1f3ab2430aa9b5ccaef1300b4b6f124 Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Tue, 31 Dec 2019 14:52:37 +0100
Subject: [PATCH 006/189] add file

---
 stan/math/rev/core/recover_memory_global.hpp | 42 ++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 stan/math/rev/core/recover_memory_global.hpp

diff --git a/stan/math/rev/core/recover_memory_global.hpp b/stan/math/rev/core/recover_memory_global.hpp
new file mode 100644
index 00000000000..ef48078adf8
--- /dev/null
+++ b/stan/math/rev/core/recover_memory_global.hpp
@@ -0,0 +1,42 @@
+#ifndef STAN_MATH_REV_CORE_RECOVER_MEMORY_GLOBAL_HPP
+#define STAN_MATH_REV_CORE_RECOVER_MEMORY_GLOBAL_HPP
+
+#include <stan/math/rev/core/vari.hpp>
+#include <stan/math/rev/core/chainablestack.hpp>
+#include <stan/math/rev/core/empty_nested.hpp>
+#include <stdexcept>
+
+namespace stan {
+namespace math {
+
+/**
+ * Recover memory global used for all variables for reuse in all
+ * threads.
+ *
+ * @throw std::logic_error if <code>empty_nested()</code> returns
+ * <code>false</code>
+ */
+static inline void recover_memory_global() {
+  /* todo: check for each thread
+  if (!empty_nested()) {
+    throw std::logic_error(
+        "empty_nested() must be true"
+        " before calling recover_memory()");
+  }
+  */
+
+  for (auto & [ thread, instance ] :
+       internal::global_observer.thread_tape_map) {
+    instance_->var_stack_.clear();
+    instance_->var_nochain_stack_.clear();
+    for (auto &x : instance_->var_alloc_stack_) {
+      delete x;
+    }
+    instance_->var_alloc_stack_.clear();
+    instance_->memalloc_.recover_all();
+  }
+}
+
+}  // namespace math
+}  // namespace stan
+#endif

From acbb3dcbec3eaae373a6abbc604adacebe1205fe Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Tue, 31 Dec 2019 15:03:26 +0100
Subject: [PATCH 007/189] fix

---
 stan/math/rev/core/autodiffstackstorage.hpp  |  5 ++++-
 stan/math/rev/core/recover_memory_global.hpp | 14 +++++++-------
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/stan/math/rev/core/autodiffstackstorage.hpp b/stan/math/rev/core/autodiffstackstorage.hpp
index 9009e1b0da0..dd7abf0a67e 100644
--- a/stan/math/rev/core/autodiffstackstorage.hpp
+++ b/stan/math/rev/core/autodiffstackstorage.hpp
@@ -90,7 +90,8 @@ struct AutodiffStackSingleton {
   using AutodiffStackSingleton_t
       = AutodiffStackSingleton<ChainableT, ChainableAllocT>;
 
-  AutodiffStackSingleton() : own_instance_(init()) {}
+  AutodiffStackSingleton()
+      : own_instance_(init()), active_instance_(instance_) {}
   ~AutodiffStackSingleton() {
     if (own_instance_) {
       delete instance_;
@@ -117,6 +118,8 @@ struct AutodiffStackSingleton {
 
   static STAN_THREADS_DEF AutodiffStackStorage *instance_;
 
+  AutodiffStackStorage *active_instance_;
+
  private:
   static bool init() {
     static STAN_THREADS_DEF bool is_initialized = false;
diff --git a/stan/math/rev/core/recover_memory_global.hpp b/stan/math/rev/core/recover_memory_global.hpp
index ef48078adf8..9c54d443dee 100644
--- a/stan/math/rev/core/recover_memory_global.hpp
+++ b/stan/math/rev/core/recover_memory_global.hpp
@@ -25,15 +25,15 @@ static inline void recover_memory_global() {
   }
   */
 
-  for (auto & [ thread, instance ] :
-       internal::global_observer.thread_tape_map) {
-    instance_->var_stack_.clear();
-    instance_->var_nochain_stack_.clear();
-    for (auto &x : instance_->var_alloc_stack_) {
+  for (const auto& kv : internal::global_observer.thread_tape_map) {
+    ChainableStack& instance_ = *(kv.second->active_instance_);
+    instance_.var_stack_.clear();
+    instance_.var_nochain_stack_.clear();
+    for (auto& x : instance_.var_alloc_stack_) {
       delete x;
     }
-    instance_->var_alloc_stack_.clear();
-    instance_->memalloc_.recover_all();
+    instance_.var_alloc_stack_.clear();
+    instance_.memalloc_.recover_all();
   }
 }
 

From bc2a6015d50d48727d316d24dd2122611b245c3d Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Tue, 31 Dec 2019 15:23:21 +0100
Subject: [PATCH 008/189] fix

---
 stan/math/rev/core/autodiffstackstorage.hpp  |  4 +++-
 stan/math/rev/core/recover_memory_global.hpp | 21 +++++++++++++-------
 2 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/stan/math/rev/core/autodiffstackstorage.hpp b/stan/math/rev/core/autodiffstackstorage.hpp
index dd7abf0a67e..860fb5de95a 100644
--- a/stan/math/rev/core/autodiffstackstorage.hpp
+++ b/stan/math/rev/core/autodiffstackstorage.hpp
@@ -91,7 +91,9 @@ struct AutodiffStackSingleton {
       = AutodiffStackSingleton<ChainableT, ChainableAllocT>;
 
   AutodiffStackSingleton()
-      : own_instance_(init()), active_instance_(instance_) {}
+      : own_instance_(init()), active_instance_(nullptr) {
+    active_instance_ = AutodiffStackSingleton_t::instance_;
+  }
   ~AutodiffStackSingleton() {
     if (own_instance_) {
       delete instance_;
diff --git a/stan/math/rev/core/recover_memory_global.hpp b/stan/math/rev/core/recover_memory_global.hpp
index 9c54d443dee..c961948b6a2 100644
--- a/stan/math/rev/core/recover_memory_global.hpp
+++ b/stan/math/rev/core/recover_memory_global.hpp
@@ -6,6 +6,8 @@
 #include <stan/math/rev/core/empty_nested.hpp>
 #include <stdexcept>
 
+#include <iostream>
+
 namespace stan {
 namespace math {
 
@@ -25,15 +27,20 @@ static inline void recover_memory_global() {
   }
   */
 
-  for (const auto& kv : internal::global_observer.thread_tape_map) {
-    ChainableStack& instance_ = *(kv.second->active_instance_);
-    instance_.var_stack_.clear();
-    instance_.var_nochain_stack_.clear();
-    for (auto& x : instance_.var_alloc_stack_) {
+  for (auto& kv : internal::global_observer.thread_tape_map_) {
+    ChainableStack::AutodiffStackStorage* instance_ = kv.second->active_instance_;
+    std::cout << "reference ptr: " << instance_ << std::endl;
+    if (instance_ == nullptr) {
+      std::cout << "nullptr ??" << std::endl;
+      continue;
+    }
+    instance_->var_stack_.clear();
+    instance_->var_nochain_stack_.clear();
+    for (auto& x : instance_->var_alloc_stack_) {
       delete x;
     }
-    instance_.var_alloc_stack_.clear();
-    instance_.memalloc_.recover_all();
+    instance_->var_alloc_stack_.clear();
+    instance_->memalloc_.recover_all();
   }
 }
 

From eec74724be5cfdd9e410d9a74e48a5d2911a9f6d Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Tue, 31 Dec 2019 15:25:25 +0100
Subject: [PATCH 009/189] remove debugging msg

---
 stan/math/rev/core/recover_memory_global.hpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/stan/math/rev/core/recover_memory_global.hpp b/stan/math/rev/core/recover_memory_global.hpp
index c961948b6a2..e6377ba7eb0 100644
--- a/stan/math/rev/core/recover_memory_global.hpp
+++ b/stan/math/rev/core/recover_memory_global.hpp
@@ -27,13 +27,15 @@ static inline void recover_memory_global() {
   }
   */
 
+  std::size_t i = 0;
+
   for (auto& kv : internal::global_observer.thread_tape_map_) {
     ChainableStack::AutodiffStackStorage* instance_ = kv.second->active_instance_;
-    std::cout << "reference ptr: " << instance_ << std::endl;
     if (instance_ == nullptr) {
-      std::cout << "nullptr ??" << std::endl;
+      std::cout << "nullptr for thread " << i << " ?? "<< std::endl;
       continue;
     }
+    i++;
     instance_->var_stack_.clear();
     instance_->var_nochain_stack_.clear();
     for (auto& x : instance_->var_alloc_stack_) {

From 2d696c8cd506e8a12cff494961a1a2cc07c180cd Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Wed, 1 Jan 2020 13:57:09 +0100
Subject: [PATCH 010/189] omit recover_memory_global which is not needed

---
 stan/math/rev/core.hpp                       |  1 -
 stan/math/rev/core/autodiffstackstorage.hpp  |  7 +--
 stan/math/rev/core/init_chainablestack.hpp   |  7 +--
 stan/math/rev/core/recover_memory_global.hpp | 51 --------------------
 4 files changed, 5 insertions(+), 61 deletions(-)
 delete mode 100644 stan/math/rev/core/recover_memory_global.hpp

diff --git a/stan/math/rev/core.hpp b/stan/math/rev/core.hpp
index b44f1cce469..db951f75576 100644
--- a/stan/math/rev/core.hpp
+++ b/stan/math/rev/core.hpp
@@ -43,7 +43,6 @@
 #include <stan/math/rev/core/print_stack.hpp>
 #include <stan/math/rev/core/recover_memory.hpp>
 #include <stan/math/rev/core/recover_memory_nested.hpp>
-#include <stan/math/rev/core/recover_memory_global.hpp>
 #include <stan/math/rev/core/set_zero_all_adjoints.hpp>
 #include <stan/math/rev/core/set_zero_all_adjoints_nested.hpp>
 #include <stan/math/rev/core/start_nested.hpp>
diff --git a/stan/math/rev/core/autodiffstackstorage.hpp b/stan/math/rev/core/autodiffstackstorage.hpp
index 860fb5de95a..9009e1b0da0 100644
--- a/stan/math/rev/core/autodiffstackstorage.hpp
+++ b/stan/math/rev/core/autodiffstackstorage.hpp
@@ -90,10 +90,7 @@ struct AutodiffStackSingleton {
   using AutodiffStackSingleton_t
       = AutodiffStackSingleton<ChainableT, ChainableAllocT>;
 
-  AutodiffStackSingleton()
-      : own_instance_(init()), active_instance_(nullptr) {
-    active_instance_ = AutodiffStackSingleton_t::instance_;
-  }
+  AutodiffStackSingleton() : own_instance_(init()) {}
   ~AutodiffStackSingleton() {
     if (own_instance_) {
       delete instance_;
@@ -120,8 +117,6 @@ struct AutodiffStackSingleton {
 
   static STAN_THREADS_DEF AutodiffStackStorage *instance_;
 
-  AutodiffStackStorage *active_instance_;
-
  private:
   static bool init() {
     static STAN_THREADS_DEF bool is_initialized = false;
diff --git a/stan/math/rev/core/init_chainablestack.hpp b/stan/math/rev/core/init_chainablestack.hpp
index 54646d85d66..8f1b903cc9e 100644
--- a/stan/math/rev/core/init_chainablestack.hpp
+++ b/stan/math/rev/core/init_chainablestack.hpp
@@ -53,15 +53,16 @@ class ad_tape_observer : public tbb::task_scheduler_observer {
     }
   }
 
+ private:
   ad_map thread_tape_map_;
   std::mutex thread_tape_map_mutex_;
 };
 
-namespace internal {
+namespace {
 
-static ad_tape_observer global_observer;
+ad_tape_observer global_observer;
 
-}  // namespace internal
+}  // namespace
 }  // namespace math
 }  // namespace stan
 
diff --git a/stan/math/rev/core/recover_memory_global.hpp b/stan/math/rev/core/recover_memory_global.hpp
deleted file mode 100644
index e6377ba7eb0..00000000000
--- a/stan/math/rev/core/recover_memory_global.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#ifndef STAN_MATH_REV_CORE_RECOVER_MEMORY_GLOBAL_HPP
-#define STAN_MATH_REV_CORE_RECOVER_MEMORY_GLOBAL_HPP
-
-#include <stan/math/rev/core/vari.hpp>
-#include <stan/math/rev/core/chainablestack.hpp>
-#include <stan/math/rev/core/empty_nested.hpp>
-#include <stdexcept>
-
-#include <iostream>
-
-namespace stan {
-namespace math {
-
-/**
- * Recover memory global used for all variables for reuse in all
- * threads.
- *
- * @throw std::logic_error if <code>empty_nested()</code> returns
- * <code>false</code>
- */
-static inline void recover_memory_global() {
-  /* todo: check for each thread
-  if (!empty_nested()) {
-    throw std::logic_error(
-        "empty_nested() must be true"
-        " before calling recover_memory()");
-  }
-  */
-
-  std::size_t i = 0;
-
-  for (auto& kv : internal::global_observer.thread_tape_map_) {
-    ChainableStack::AutodiffStackStorage* instance_ = kv.second->active_instance_;
-    if (instance_ == nullptr) {
-      std::cout << "nullptr for thread " << i << " ?? "<< std::endl;
-      continue;
-    }
-    i++;
-    instance_->var_stack_.clear();
-    instance_->var_nochain_stack_.clear();
-    for (auto& x : instance_->var_alloc_stack_) {
-      delete x;
-    }
-    instance_->var_alloc_stack_.clear();
-    instance_->memalloc_.recover_all();
-  }
-}
-
-}  // namespace math
-}  // namespace stan
-#endif

From 6d8ad8a4f7b71774d2578828f6326f5be9c50d02 Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Wed, 1 Jan 2020 14:16:37 +0100
Subject: [PATCH 011/189] aggregate more efficiently the partial sums

---
 .../rev/scal/functor/parallel_reduce_sum.hpp  | 52 +++++++++----------
 1 file changed, 25 insertions(+), 27 deletions(-)

diff --git a/stan/math/rev/scal/functor/parallel_reduce_sum.hpp b/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
index c0f22dd6ea0..eb578c0de8a 100644
--- a/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
+++ b/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
@@ -21,14 +21,15 @@ namespace internal {
 
 template <class ReduceFunction, class InputIt, class T, class Arg1>
 struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
-  using ops_partials_t = operands_and_partials<std::vector<Arg1>>;
+  using ops_partials_t
+      = operands_and_partials<std::vector<Arg1>, const std::vector<int>>;
 
   struct recursive_reducer {
     InputIt first_;
     std::vector<Arg1>& varg1_;
     const std::vector<int>& idata1_;
-    std::vector<std::vector<double>> terms_adjs_;
-    std::vector<double> terms_vals_;
+    ops_partials_t terms_partials_;
+    double terms_sum_;
     typedef typename std::iterator_traits<InputIt>::value_type elem_t;
 
     recursive_reducer(InputIt first, const T& init, std::vector<Arg1>& varg1,
@@ -36,16 +37,15 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
         : first_(first),
           varg1_(varg1),
           idata1_(idata1),
-          terms_adjs_(1, std::vector<double>(varg1.size(), 0.0)),
-          terms_vals_(1, init.val()) {}
+          terms_partials_(varg1_, idata1_),
+          terms_sum_(init.val()) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
         : first_(other.first_),
           varg1_(other.varg1_),
           idata1_(other.idata1_),
-          terms_adjs_(),
-          terms_vals_() {}
-    // terms_adjs_(other.terms_adjs_), terms_vals_(other.terms_vals_) {}
+          terms_partials_(varg1_, idata1_),
+          terms_sum_(0.0) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty())
@@ -64,7 +64,13 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
         // right now we discard that it is a var if it would be)
         std::vector<elem_t> sub_slice(start, end);
 
-        // create a deep copy of arg1 which is not tied to the outer AD tree
+        // create a deep copy of arg1 which is not tied to the outer
+        // AD tree
+        // todo: these copies can be put onto a thread-local storage
+        // object such that we only create these once per thread which
+        // should significantly boost performance as many copies are
+        // avoided... this comes at the cost that the adjoints have to
+        // be zeroed "manually"
         std::vector<Arg1> varg1;
         varg1.reserve(varg1_.size());
 
@@ -76,13 +82,10 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
 
         sub_sum_v.grad();
 
-        terms_vals_.push_back(sub_sum_v.val());
+        terms_sum_ += sub_sum_v.val();
 
-        std::vector<double> varg1_adj;
-        for (const Arg1& elem : varg1)
-          varg1_adj.push_back(elem.adj());
-
-        terms_adjs_.push_back(varg1_adj);
+        for (std::size_t i = 0; i != varg1.size(); ++i)
+          terms_partials_.edge1_.partials_[i] += varg1[i].adj();
 
       } catch (const std::exception& e) {
         recover_memory_nested();
@@ -90,11 +93,13 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
       }
       recover_memory_nested();
     }
+
     void join(const recursive_reducer& child) {
-      terms_adjs_.insert(terms_adjs_.end(), child.terms_adjs_.begin(),
-                         child.terms_adjs_.end());
-      terms_vals_.insert(terms_vals_.end(), child.terms_vals_.begin(),
-                         child.terms_vals_.end());
+      terms_sum_ += child.terms_sum_;
+
+      for (std::size_t i = 0; i != varg1_.size(); ++i)
+        terms_partials_.edge1_.partials_[i]
+            += child.terms_partials_.edge1_.partials_[i];
     }
   };
 
@@ -104,14 +109,7 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
     recursive_reducer worker(first, init, varg1, idata);
     tbb::parallel_reduce(
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
-    ops_partials_t ops_sum(varg1);
-    double sum = 0.0;
-    for (std::size_t i = 0; i != worker.terms_adjs_.size(); ++i) {
-      sum += worker.terms_vals_[i];
-      for (std::size_t j = 0; j != worker.terms_adjs_[i].size(); ++j)
-        ops_sum.edge1_.partials_[j] += worker.terms_adjs_[i][j];
-    }
-    return ops_sum.build(sum);
+    return worker.terms_partials_.build(worker.terms_sum_);
   }
 };
 }  // namespace internal

From 1a54bde31e43543445db96efb6b90c6c87999793 Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Thu, 2 Jan 2020 10:54:10 +0100
Subject: [PATCH 012/189] simplify how values are copied

---
 stan/math/rev/scal/functor/parallel_reduce_sum.hpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/stan/math/rev/scal/functor/parallel_reduce_sum.hpp b/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
index eb578c0de8a..9e20a448d62 100644
--- a/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
+++ b/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
@@ -71,11 +71,18 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
         // should significantly boost performance as many copies are
         // avoided... this comes at the cost that the adjoints have to
         // be zeroed "manually"
+        /* using the var_nochain_stack_ tape avoids up-propagation of chain
         std::vector<Arg1> varg1;
         varg1.reserve(varg1_.size());
 
         for (Arg1& elem : varg1_)
           varg1.emplace_back(var(new vari(elem.val(), false)));
+        */
+
+        // but this should actually do the same if we simply
+        // instantiate the var from a double representation
+        std::vector<double> varg1_d = value_of(varg1_);
+        std::vector<Arg1> varg1(varg1_d.begin(), varg1_d.end());
 
         T sub_sum_v = ReduceFunction()(r.begin(), r.end() - 1, sub_slice, varg1,
                                        idata1_);

From f689c93481cb42167b5e5df6bb14a66c356039f4 Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Thu, 2 Jan 2020 11:09:40 +0100
Subject: [PATCH 013/189] const correctness

---
 .../prim/scal/functor/parallel_reduce_sum.hpp    | 11 +++++++----
 .../rev/scal/functor/parallel_reduce_sum.hpp     | 16 ++++++++++------
 2 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/stan/math/prim/scal/functor/parallel_reduce_sum.hpp b/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
index 415b925f8cd..b2fc6669abe 100644
--- a/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
@@ -28,12 +28,13 @@ template <class ReduceFunction, class InputIt, class T, class Arg1>
 struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, double> {
   struct recursive_reducer {
     InputIt first_;
-    std::vector<Arg1>& varg1_;
+    const std::vector<Arg1>& varg1_;
     const std::vector<int>& idata1_;
     T sum_;
     typedef typename std::iterator_traits<InputIt>::value_type elem_t;
 
-    recursive_reducer(InputIt first, const T& init, std::vector<Arg1>& varg1,
+    recursive_reducer(InputIt first, const T& init,
+                      const std::vector<Arg1>& varg1,
                       const std::vector<int>& idata1)
         : first_(first), varg1_(varg1), idata1_(idata1), sum_(init) {}
 
@@ -62,7 +63,8 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, double> {
   };
 
   T operator()(InputIt first, InputIt last, T init, std::size_t grainsize,
-               std::vector<Arg1>& varg1, const std::vector<int>& idata1) const {
+               const std::vector<Arg1>& varg1,
+               const std::vector<int>& idata1) const {
     const std::size_t num_jobs = std::distance(first, last);
     recursive_reducer worker(first, init, varg1, idata1);
     tbb::parallel_reduce(
@@ -114,7 +116,8 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, double> {
  */
 template <class ReduceFunction, class InputIt, class T, class Arg1>
 constexpr T parallel_reduce_sum(InputIt first, InputIt last, T init,
-                                std::size_t grainsize, std::vector<Arg1>& varg1,
+                                std::size_t grainsize,
+                                const std::vector<Arg1>& varg1,
                                 const std::vector<int>& idata1) {
   typedef T return_base_t;
   return internal::parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1,
diff --git a/stan/math/rev/scal/functor/parallel_reduce_sum.hpp b/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
index 9e20a448d62..8c8a6e62fb7 100644
--- a/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
+++ b/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
@@ -26,13 +26,14 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
 
   struct recursive_reducer {
     InputIt first_;
-    std::vector<Arg1>& varg1_;
+    const std::vector<Arg1>& varg1_;
     const std::vector<int>& idata1_;
     ops_partials_t terms_partials_;
     double terms_sum_;
     typedef typename std::iterator_traits<InputIt>::value_type elem_t;
 
-    recursive_reducer(InputIt first, const T& init, std::vector<Arg1>& varg1,
+    recursive_reducer(InputIt first, const T& init,
+                      const std::vector<Arg1>& varg1,
                       const std::vector<int>& idata1)
         : first_(first),
           varg1_(varg1),
@@ -81,7 +82,7 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
 
         // but this should actually do the same if we simply
         // instantiate the var from a double representation
-        std::vector<double> varg1_d = value_of(varg1_);
+        const std::vector<double> varg1_d = value_of(varg1_);
         std::vector<Arg1> varg1(varg1_d.begin(), varg1_d.end());
 
         T sub_sum_v = ReduceFunction()(r.begin(), r.end() - 1, sub_slice, varg1,
@@ -111,11 +112,14 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
   };
 
   T operator()(InputIt first, InputIt last, T init, std::size_t grainsize,
-               std::vector<Arg1>& varg1, const std::vector<int>& idata) const {
+               const std::vector<Arg1>& varg1,
+               const std::vector<int>& idata) const {
     const std::size_t num_jobs = std::distance(first, last);
     recursive_reducer worker(first, init, varg1, idata);
-    tbb::parallel_reduce(
-        tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
+    tbb::static_partitioner work_partitioner;
+    tbb::parallel_deterministic_reduce(
+        tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker,
+        work_partitioner);
     return worker.terms_partials_.build(worker.terms_sum_);
   }
 };

From 0da9de09f51243cb6c8c7fa01a2f7e9fe2de71fd Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Thu, 2 Jan 2020 19:28:41 +0100
Subject: [PATCH 014/189] make code more generic (some meta magic bits are
 missing)

---
 .../prim/scal/functor/parallel_reduce_sum.hpp |  76 +++++----
 .../rev/scal/functor/parallel_reduce_sum.hpp  | 153 ++++++++++++------
 .../functor/parallel_v3_reduce_sum_test.cpp   |  20 +--
 3 files changed, 159 insertions(+), 90 deletions(-)

diff --git a/stan/math/prim/scal/functor/parallel_reduce_sum.hpp b/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
index b2fc6669abe..16e316819ac 100644
--- a/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
@@ -20,56 +20,62 @@ namespace math {
 namespace internal {
 
 // base definition => compile error
-template <class ReduceFunction, class InputIt, class T, class Arg1,
+template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
           class T_return_type>
 struct parallel_reduce_sum_impl {};
 
-template <class ReduceFunction, class InputIt, class T, class Arg1>
-struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, double> {
-  struct recursive_reducer {
-    InputIt first_;
-    const std::vector<Arg1>& varg1_;
-    const std::vector<int>& idata1_;
-    T sum_;
-    typedef typename std::iterator_traits<InputIt>::value_type elem_t;
+template <class ReduceFunction, class M, class T, class Arg1, class Arg2>
+struct parallel_reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, double> {
+  using vmapped_t = std::vector<M>;
+  using arg1_t = std::vector<Arg1>;
+  using arg2_t = std::vector<Arg2>;
 
-    recursive_reducer(InputIt first, const T& init,
-                      const std::vector<Arg1>& varg1,
-                      const std::vector<int>& idata1)
-        : first_(first), varg1_(varg1), idata1_(idata1), sum_(init) {}
+  struct recursive_reducer {
+    const vmapped_t& vmapped_;
+    const arg1_t& arg1_;
+    const arg2_t& arg2_;
+    T terms_sum_;
+
+    recursive_reducer(const vmapped_t& vmapped, const T& init,
+                      const arg1_t& arg1, const arg2_t& arg2)
+        : vmapped_(vmapped),
+          arg1_(arg1),
+          arg2_(arg2),
+          terms_sum_(value_of(init)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-        : first_(other.first_),
-          varg1_(other.varg1_),
-          idata1_(other.idata1_),
-          sum_(T(0.0)) {}
+        : vmapped_(other.vmapped_),
+          arg1_(other.arg1_),
+          arg2_(other.arg2_),
+          terms_sum_(0.0) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty())
         return;
 
-      auto start = first_;
+      auto start = vmapped_.begin();
       std::advance(start, r.begin());
-      auto end = first_;
+      auto end = vmapped_.begin();
       std::advance(end, r.end());
 
-      std::vector<elem_t> sub_slice(start, end);
+      vmapped_t sub_slice(start, end);
 
-      sum_ += ReduceFunction()(r.begin(), r.end() - 1, sub_slice, varg1_,
-                               idata1_);
+      terms_sum_
+          += ReduceFunction()(r.begin(), r.end() - 1, sub_slice, arg1_, arg2_);
     }
 
-    void join(const recursive_reducer& child) { sum_ += child.sum_; }
+    void join(const recursive_reducer& child) {
+      terms_sum_ += child.terms_sum_;
+    }
   };
 
-  T operator()(InputIt first, InputIt last, T init, std::size_t grainsize,
-               const std::vector<Arg1>& varg1,
-               const std::vector<int>& idata1) const {
-    const std::size_t num_jobs = std::distance(first, last);
-    recursive_reducer worker(first, init, varg1, idata1);
+  T operator()(const vmapped_t& vmapped, T init, std::size_t grainsize,
+               const arg1_t& arg1, const arg2_t& arg2) const {
+    const std::size_t num_jobs = vmapped.size();
+    recursive_reducer worker(vmapped, init, arg1, arg2);
     tbb::parallel_reduce(
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
-    return std::move(worker.sum_);
+    return std::move(worker.terms_sum_);
   }
 };
 }  // namespace internal
@@ -114,15 +120,15 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, double> {
  * the functor must be default constructible without any arguments.
  *
  */
-template <class ReduceFunction, class InputIt, class T, class Arg1>
-constexpr T parallel_reduce_sum(InputIt first, InputIt last, T init,
+template <class ReduceFunction, class M, class T, class Arg1, class Arg2>
+constexpr T parallel_reduce_sum(const std::vector<M>& vmapped, T init,
                                 std::size_t grainsize,
-                                const std::vector<Arg1>& varg1,
-                                const std::vector<int>& idata1) {
+                                const std::vector<Arg1>& arg1,
+                                const std::vector<Arg2>& arg2) {
   typedef T return_base_t;
-  return internal::parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1,
+  return internal::parallel_reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2,
                                             return_base_t>()(
-      first, last, init, grainsize, varg1, idata1);
+      vmapped, init, grainsize, arg1, arg2);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/scal/functor/parallel_reduce_sum.hpp b/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
index 8c8a6e62fb7..97ddfadba49 100644
--- a/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
+++ b/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
@@ -1,7 +1,7 @@
 #ifndef STAN_MATH_REV_SCAL_FUNCTOR_PARALLEL_REDUCE_SUM_HPP
 #define STAN_MATH_REV_SCAL_FUNCTOR_PARALLEL_REDUCE_SUM_HPP
 
-#include <stan/math/prim/meta/return_type.hpp>
+#include <stan/math/prim/meta.hpp>
 #include <stan/math/rev/mat/fun/typedefs.hpp>
 
 #include <boost/iterator/counting_iterator.hpp>
@@ -19,51 +19,69 @@ namespace math {
 
 namespace internal {
 
-template <class ReduceFunction, class InputIt, class T, class Arg1>
-struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
+template <class ReduceFunction, class M, class T, class Arg1, class Arg2>
+struct parallel_reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, var> {
+  using vmapped_t = std::vector<M>;
+  using arg1_t = std::vector<Arg1>;
+  using arg2_t = std::vector<Arg2>;
+
+  using vmapped_value_t = std::vector<typename child_type<M>::type>;
+  using arg1_value_t = std::vector<typename child_type<Arg1>::type>;
+  // using arg2_value_t = std::vector<typename child_type<Arg2>::type>;
+  using arg2_value_t = std::vector<int>;
+
   using ops_partials_t
-      = operands_and_partials<std::vector<Arg1>, const std::vector<int>>;
+      = operands_and_partials<vmapped_t, std::vector<Arg1>, std::vector<Arg2>>;
 
   struct recursive_reducer {
-    InputIt first_;
-    const std::vector<Arg1>& varg1_;
-    const std::vector<int>& idata1_;
-    ops_partials_t terms_partials_;
+    const vmapped_t& vmapped_;
+    const arg1_t& arg1_;
+    const arg1_value_t& arg1_value_;
+    const arg2_t& arg2_;
+    const arg2_value_t& arg2_value_;
+
+    ops_partials_t& terms_partials_mapped_;
+    ops_partials_t terms_partials_args_;
     double terms_sum_;
-    typedef typename std::iterator_traits<InputIt>::value_type elem_t;
 
-    recursive_reducer(InputIt first, const T& init,
-                      const std::vector<Arg1>& varg1,
-                      const std::vector<int>& idata1)
-        : first_(first),
-          varg1_(varg1),
-          idata1_(idata1),
-          terms_partials_(varg1_, idata1_),
-          terms_sum_(init.val()) {}
+    recursive_reducer(const vmapped_t& vmapped, const T& init,
+                      const arg1_t& arg1, const arg1_value_t& arg1_value,
+                      const arg2_t& arg2, const arg2_value_t& arg2_value,
+                      ops_partials_t& terms_partials_mapped)
+        : vmapped_(vmapped),
+          arg1_(arg1),
+          arg1_value_(arg1_value),
+          arg2_(arg2),
+          arg2_value_(arg2_value),
+          terms_partials_mapped_(terms_partials_mapped),
+          terms_partials_args_(vmapped, arg1, arg2),
+          terms_sum_(value_of(init)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-        : first_(other.first_),
-          varg1_(other.varg1_),
-          idata1_(other.idata1_),
-          terms_partials_(varg1_, idata1_),
+        : vmapped_(other.vmapped_),
+          arg1_(other.arg1_),
+          arg1_value_(other.arg1_value_),
+          arg2_(other.arg2_),
+          arg2_value_(other.arg2_value_),
+          terms_partials_mapped_(other.terms_partials_mapped_),
+          terms_partials_args_(vmapped_, arg1_, arg2_),
           terms_sum_(0.0) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty())
         return;
 
-      auto start = first_;
-      std::advance(start, r.begin());
-      auto end = first_;
-      std::advance(end, r.end());
-
       try {
         start_nested();
 
         // elem_t should better be a non-var!!! Otherwise we interfere
         // with the outer AD tree as we mess with the adjoints (and
         // right now we discard that it is a var if it would be)
-        std::vector<elem_t> sub_slice(start, end);
+        vmapped_t local_sub_slice;
+
+        local_sub_slice.reserve(r.size());
+        for (std::size_t i = r.begin(); i != r.end(); ++i)
+          local_sub_slice.emplace_back(value_of(vmapped_[i]));
 
         // create a deep copy of arg1 which is not tied to the outer
         // AD tree
@@ -82,18 +100,38 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
 
         // but this should actually do the same if we simply
         // instantiate the var from a double representation
-        const std::vector<double> varg1_d = value_of(varg1_);
-        std::vector<Arg1> varg1(varg1_d.begin(), varg1_d.end());
+        // const std::vector<double> varg1_d = value_of(varg1_);
+        // std::vector<Arg1> varg1(varg1_d.begin(), varg1_d.end());
+
+        arg1_t local_arg1(arg1_value_.begin(), arg1_value_.end());
+        arg2_t local_arg2(arg2_value_.begin(), arg2_value_.end());
 
-        T sub_sum_v = ReduceFunction()(r.begin(), r.end() - 1, sub_slice, varg1,
-                                       idata1_);
+        T sub_sum_v = ReduceFunction()(r.begin(), r.end() - 1, local_sub_slice,
+                                       local_arg1, local_arg2);
 
         sub_sum_v.grad();
 
         terms_sum_ += sub_sum_v.val();
 
-        for (std::size_t i = 0; i != varg1.size(); ++i)
-          terms_partials_.edge1_.partials_[i] += varg1[i].adj();
+        /*
+        if (!is_constant_all<M>::value) {
+          for (std::size_t i = 0; i != r.size(); ++i)
+            terms_partials_mapped_.edge1_.partials_[r.begin() + i] +=
+        local_sub_slice[i].adj();
+        }
+        */
+
+        if (!is_constant_all<Arg1>::value) {
+          for (std::size_t i = 0; i != local_arg1.size(); ++i)
+            terms_partials_args_.edge2_.partials_[i] += local_arg1[i].adj();
+        }
+
+        /*
+        if (!is_constant_all<Arg2>::value) {
+          for (std::size_t i = 0; i != local_arg2.size(); ++i)
+            terms_partials_args_.edge3_.partials_[i] += local_arg2[i].adj();
+        }
+        */
 
       } catch (const std::exception& e) {
         recover_memory_nested();
@@ -105,22 +143,45 @@ struct parallel_reduce_sum_impl<ReduceFunction, InputIt, T, Arg1, var> {
     void join(const recursive_reducer& child) {
       terms_sum_ += child.terms_sum_;
 
-      for (std::size_t i = 0; i != varg1_.size(); ++i)
-        terms_partials_.edge1_.partials_[i]
-            += child.terms_partials_.edge1_.partials_[i];
+      if (!is_constant_all<Arg1>::value) {
+        for (std::size_t i = 0; i != arg1_.size(); ++i)
+          terms_partials_args_.edge2_.partials_[i]
+              += child.terms_partials_args_.edge2_.partials_[i];
+      }
+
+      /*
+      if (!is_constant_all<Arg2>::value) {
+        for (std::size_t i = 0; i != arg2_.size(); ++i)
+          terms_partials_args_.edge3_.partials_[i]
+              += child.terms_partials_args_.edge3_.partials_[i];
+      }
+      */
     }
   };
 
-  T operator()(InputIt first, InputIt last, T init, std::size_t grainsize,
-               const std::vector<Arg1>& varg1,
-               const std::vector<int>& idata) const {
-    const std::size_t num_jobs = std::distance(first, last);
-    recursive_reducer worker(first, init, varg1, idata);
-    tbb::static_partitioner work_partitioner;
-    tbb::parallel_deterministic_reduce(
-        tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker,
-        work_partitioner);
-    return worker.terms_partials_.build(worker.terms_sum_);
+  T operator()(const vmapped_t& vmapped, T init, std::size_t grainsize,
+               const arg1_t& arg1, const arg2_t& arg2) const {
+    const std::size_t num_jobs = vmapped.size();
+    arg1_value_t arg1_value = value_of(arg1);
+    arg2_value_t arg2_value = value_of(arg2);
+
+    ops_partials_t ops(vmapped, arg1, arg2);
+
+    recursive_reducer worker(vmapped, init, arg1, arg1_value, arg2, arg2_value,
+                             ops);
+
+    tbb::parallel_reduce(
+        tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
+
+    if (!is_constant_all<Arg1>::value) {
+      ops.edge2_.partials_ = worker.terms_partials_args_.edge2_.partials_;
+    }
+
+    if (!is_constant_all<Arg2>::value) {
+      ops.edge3_.partials_ = worker.terms_partials_args_.edge3_.partials_;
+    }
+
+    return ops.build(worker.terms_sum_);
   }
 };
 }  // namespace internal
diff --git a/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
index d9616dcc150..e9d652dcfe0 100644
--- a/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
@@ -14,7 +14,8 @@ struct count_lpdf {
 
   // does the reduction in the sub-slice start to end
   inline T operator()(std::size_t start, std::size_t end,
-                      std::vector<int>& sub_slice, std::vector<T>& lambda,
+                      const std::vector<int>& sub_slice,
+                      const std::vector<T>& lambda,
                       const std::vector<int>& idata) const {
     return stan::math::poisson_lpmf(sub_slice, lambda[0]);
   }
@@ -37,7 +38,7 @@ TEST(parallel_v3_reduce_sum, value) {
   typedef boost::counting_iterator<std::size_t> count_iter;
 
   double poisson_lpdf = stan::math::parallel_reduce_sum<count_lpdf<double>>(
-      data.begin(), data.end(), 0.0, 5, vlambda_d, idata);
+      data, 0.0, 5, vlambda_d, idata);
 
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
 
@@ -70,7 +71,7 @@ TEST(parallel_v3_reduce_sum, gradient) {
   std::vector<var> vlambda_v(1, lambda_v);
 
   var poisson_lpdf = stan::math::parallel_reduce_sum<count_lpdf<var>>(
-      data.begin(), data.end(), var(0.0), 5, vlambda_v, idata);
+      data, var(0.0), 5, vlambda_v, idata);
 
   var lambda_ref = lambda_d;
   var poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_ref);
@@ -109,10 +110,11 @@ struct nesting_count_lpdf {
 
   // does the reduction in the sub-slice start to end
   inline T operator()(std::size_t start, std::size_t end,
-                      std::vector<int>& sub_slice, std::vector<T>& lambda,
+                      const std::vector<int>& sub_slice,
+                      const std::vector<T>& lambda,
                       const std::vector<int>& idata) const {
-    return stan::math::parallel_reduce_sum<count_lpdf<T>>(
-        sub_slice.begin(), sub_slice.end(), T(0.0), 5, lambda, idata);
+    return stan::math::parallel_reduce_sum<count_lpdf<T>>(sub_slice, T(0.0), 5,
+                                                          lambda, idata);
   }
 };
 
@@ -133,7 +135,7 @@ TEST(parallel_v3_reduce_sum, nesting_value) {
   typedef boost::counting_iterator<std::size_t> count_iter;
 
   double poisson_lpdf = stan::math::parallel_reduce_sum<count_lpdf<double>>(
-      data.begin(), data.end(), 0.0, 5, vlambda_d, idata);
+      data, 0.0, 5, vlambda_d, idata);
 
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
 
@@ -166,7 +168,7 @@ TEST(parallel_v3_reduce_sum, nesting_gradient) {
   std::vector<var> vlambda_v(1, lambda_v);
 
   var poisson_lpdf = stan::math::parallel_reduce_sum<nesting_count_lpdf<var>>(
-      data.begin(), data.end(), var(0.0), 5, vlambda_v, idata);
+      data, var(0.0), 5, vlambda_v, idata);
 
   var lambda_ref = lambda_d;
   var poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_ref);
@@ -245,7 +247,7 @@ TEST(parallel_v3_reduce_sum, grouped_gradient) {
   var lambda_v = vlambda_v[0];
 
   var poisson_lpdf = stan::math::parallel_reduce_sum<grouped_count_lpdf<var>>(
-      data.begin(), data.end(), var(0.0), 5, vlambda_v, gidx);
+      data, var(0.0), 5, vlambda_v, gidx);
 
   std::vector<var> vref_lambda_v;
   for (std::size_t i = 0; i != elems; ++i) {

From 73fb5ae75c81d95e2209436d041b10ad8b450da8 Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Fri, 3 Jan 2020 13:33:48 +0100
Subject: [PATCH 015/189] make parallel reduce sum work with posted example...
 need more meta-programs to handle general case

---
 .../rev/scal/functor/parallel_reduce_sum.hpp  | 20 +++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/stan/math/rev/scal/functor/parallel_reduce_sum.hpp b/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
index 97ddfadba49..3809a25bb84 100644
--- a/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
+++ b/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
@@ -17,6 +17,11 @@
 namespace stan {
 namespace math {
 
+template <>
+struct child_type<int> {
+  using type = int;
+};
+
 namespace internal {
 
 template <class ReduceFunction, class M, class T, class Arg1, class Arg2>
@@ -27,8 +32,7 @@ struct parallel_reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, var> {
 
   using vmapped_value_t = std::vector<typename child_type<M>::type>;
   using arg1_value_t = std::vector<typename child_type<Arg1>::type>;
-  // using arg2_value_t = std::vector<typename child_type<Arg2>::type>;
-  using arg2_value_t = std::vector<int>;
+  using arg2_value_t = std::vector<typename child_type<Arg2>::type>;
 
   using ops_partials_t
       = operands_and_partials<vmapped_t, std::vector<Arg1>, std::vector<Arg2>>;
@@ -113,18 +117,20 @@ struct parallel_reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, var> {
 
         terms_sum_ += sub_sum_v.val();
 
-        /*
+        /**/
         if (!is_constant_all<M>::value) {
           for (std::size_t i = 0; i != r.size(); ++i)
-            terms_partials_mapped_.edge1_.partials_[r.begin() + i] +=
-        local_sub_slice[i].adj();
+            terms_partials_mapped_.edge1_.partials_[r.begin() + i]
+                += local_sub_slice[i].adj();
         }
-        */
+        /**/
 
+        /*
         if (!is_constant_all<Arg1>::value) {
           for (std::size_t i = 0; i != local_arg1.size(); ++i)
             terms_partials_args_.edge2_.partials_[i] += local_arg1[i].adj();
         }
+        */
 
         /*
         if (!is_constant_all<Arg2>::value) {
@@ -143,11 +149,13 @@ struct parallel_reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, var> {
     void join(const recursive_reducer& child) {
       terms_sum_ += child.terms_sum_;
 
+      /*
       if (!is_constant_all<Arg1>::value) {
         for (std::size_t i = 0; i != arg1_.size(); ++i)
           terms_partials_args_.edge2_.partials_[i]
               += child.terms_partials_args_.edge2_.partials_[i];
       }
+      */
 
       /*
       if (!is_constant_all<Arg2>::value) {

From e7a83c6dd6502504fb70f4060ce3d42d858dd2f3 Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Sun, 5 Jan 2020 14:11:21 +0100
Subject: [PATCH 016/189] rename to reduce_sum

---
 stan/math/prim/scal.hpp                       |  2 +-
 ...parallel_reduce_sum.hpp => reduce_sum.hpp} | 16 ++++++------
 stan/math/rev/scal.hpp                        |  2 +-
 ...parallel_reduce_sum.hpp => reduce_sum.hpp} | 18 ++++++-------
 .../functor/parallel_v3_reduce_sum_test.cpp   | 26 +++++++++----------
 5 files changed, 32 insertions(+), 32 deletions(-)
 rename stan/math/prim/scal/functor/{parallel_reduce_sum.hpp => reduce_sum.hpp} (89%)
 rename stan/math/rev/scal/functor/{parallel_reduce_sum.hpp => reduce_sum.hpp} (96%)

diff --git a/stan/math/prim/scal.hpp b/stan/math/prim/scal.hpp
index ea4700b4722..d25d7e7b436 100644
--- a/stan/math/prim/scal.hpp
+++ b/stan/math/prim/scal.hpp
@@ -131,7 +131,7 @@
 #include <stan/math/prim/scal/fun/value_of.hpp>
 #include <stan/math/prim/scal/fun/value_of_rec.hpp>
 
-#include <stan/math/prim/scal/functor/parallel_reduce_sum.hpp>
+#include <stan/math/prim/scal/functor/reduce_sum.hpp>
 
 #include <stan/math/prim/scal/prob/bernoulli_ccdf_log.hpp>
 #include <stan/math/prim/scal/prob/bernoulli_cdf.hpp>
diff --git a/stan/math/prim/scal/functor/parallel_reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
similarity index 89%
rename from stan/math/prim/scal/functor/parallel_reduce_sum.hpp
rename to stan/math/prim/scal/functor/reduce_sum.hpp
index 16e316819ac..333e5ef6170 100644
--- a/stan/math/prim/scal/functor/parallel_reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -1,5 +1,5 @@
-#ifndef STAN_MATH_PRIM_SCAL_FUNCTOR_PARALLEL_REDUCE_SUM_HPP
-#define STAN_MATH_PRIM_SCAL_FUNCTOR_PARALLEL_REDUCE_SUM_HPP
+#ifndef STAN_MATH_PRIM_SCAL_FUNCTOR_REDUCE_SUM_HPP
+#define STAN_MATH_PRIM_SCAL_FUNCTOR_REDUCE_SUM_HPP
 
 #include <stan/math/prim/meta/return_type.hpp>
 #include <stan/math/prim/mat/fun/typedefs.hpp>
@@ -22,10 +22,10 @@ namespace internal {
 // base definition => compile error
 template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
           class T_return_type>
-struct parallel_reduce_sum_impl {};
+struct reduce_sum_impl {};
 
 template <class ReduceFunction, class M, class T, class Arg1, class Arg2>
-struct parallel_reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, double> {
+struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, double> {
   using vmapped_t = std::vector<M>;
   using arg1_t = std::vector<Arg1>;
   using arg2_t = std::vector<Arg2>;
@@ -104,10 +104,10 @@ struct parallel_reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, double> {
  *    "..." thing in C++. The complication for this is managing all
  *    the calls.
  *
- * So the parallel_reduce_sum signature should look like
+ * So the reduce_sum signature should look like
  *
  * template <class ReduceFunction, class InputIt, class T, ...>
- * constexpr T parallel_reduce_sum(InputIt first, InputIt last, T init,
+ * constexpr T reduce_sum(InputIt first, InputIt last, T init,
  *                                std::size_t grainsize, ...)
  *
  * which corresponds to a ReduceFunction which looks like
@@ -121,12 +121,12 @@ struct parallel_reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, double> {
  *
  */
 template <class ReduceFunction, class M, class T, class Arg1, class Arg2>
-constexpr T parallel_reduce_sum(const std::vector<M>& vmapped, T init,
+constexpr T reduce_sum(const std::vector<M>& vmapped, T init,
                                 std::size_t grainsize,
                                 const std::vector<Arg1>& arg1,
                                 const std::vector<Arg2>& arg2) {
   typedef T return_base_t;
-  return internal::parallel_reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2,
+  return internal::reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2,
                                             return_base_t>()(
       vmapped, init, grainsize, arg1, arg2);
 }
diff --git a/stan/math/rev/scal.hpp b/stan/math/rev/scal.hpp
index 2ac1387a702..a8f5a55a49b 100644
--- a/stan/math/rev/scal.hpp
+++ b/stan/math/rev/scal.hpp
@@ -102,6 +102,6 @@
 #include <stan/math/rev/scal/fun/value_of.hpp>
 #include <stan/math/rev/scal/fun/value_of_rec.hpp>
 
-#include <stan/math/rev/scal/functor/parallel_reduce_sum.hpp>
+#include <stan/math/rev/scal/functor/reduce_sum.hpp>
 
 #endif
diff --git a/stan/math/rev/scal/functor/parallel_reduce_sum.hpp b/stan/math/rev/scal/functor/reduce_sum.hpp
similarity index 96%
rename from stan/math/rev/scal/functor/parallel_reduce_sum.hpp
rename to stan/math/rev/scal/functor/reduce_sum.hpp
index 3809a25bb84..df59c1d458b 100644
--- a/stan/math/rev/scal/functor/parallel_reduce_sum.hpp
+++ b/stan/math/rev/scal/functor/reduce_sum.hpp
@@ -1,5 +1,5 @@
-#ifndef STAN_MATH_REV_SCAL_FUNCTOR_PARALLEL_REDUCE_SUM_HPP
-#define STAN_MATH_REV_SCAL_FUNCTOR_PARALLEL_REDUCE_SUM_HPP
+#ifndef STAN_MATH_REV_SCAL_FUNCTOR_REDUCE_SUM_HPP
+#define STAN_MATH_REV_SCAL_FUNCTOR_REDUCE_SUM_HPP
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/rev/mat/fun/typedefs.hpp>
@@ -25,7 +25,7 @@ struct child_type<int> {
 namespace internal {
 
 template <class ReduceFunction, class M, class T, class Arg1, class Arg2>
-struct parallel_reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, var> {
+struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, var> {
   using vmapped_t = std::vector<M>;
   using arg1_t = std::vector<Arg1>;
   using arg2_t = std::vector<Arg2>;
@@ -117,20 +117,20 @@ struct parallel_reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, var> {
 
         terms_sum_ += sub_sum_v.val();
 
-        /**/
+        /*
         if (!is_constant_all<M>::value) {
           for (std::size_t i = 0; i != r.size(); ++i)
             terms_partials_mapped_.edge1_.partials_[r.begin() + i]
                 += local_sub_slice[i].adj();
         }
-        /**/
+        */
 
-        /*
+        /**/
         if (!is_constant_all<Arg1>::value) {
           for (std::size_t i = 0; i != local_arg1.size(); ++i)
             terms_partials_args_.edge2_.partials_[i] += local_arg1[i].adj();
         }
-        */
+        /**/
 
         /*
         if (!is_constant_all<Arg2>::value) {
@@ -149,13 +149,13 @@ struct parallel_reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, var> {
     void join(const recursive_reducer& child) {
       terms_sum_ += child.terms_sum_;
 
-      /*
+      /**/
       if (!is_constant_all<Arg1>::value) {
         for (std::size_t i = 0; i != arg1_.size(); ++i)
           terms_partials_args_.edge2_.partials_[i]
               += child.terms_partials_args_.edge2_.partials_[i];
       }
-      */
+      /**/
 
       /*
       if (!is_constant_all<Arg2>::value) {
diff --git a/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
index e9d652dcfe0..d879aa04d21 100644
--- a/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
@@ -21,7 +21,7 @@ struct count_lpdf {
   }
 };
 
-TEST(parallel_v3_reduce_sum, value) {
+TEST(v3_reduce_sum, value) {
   stan::math::init_threadpool_tbb();
 
   double lambda_d = 10.0;
@@ -37,7 +37,7 @@ TEST(parallel_v3_reduce_sum, value) {
 
   typedef boost::counting_iterator<std::size_t> count_iter;
 
-  double poisson_lpdf = stan::math::parallel_reduce_sum<count_lpdf<double>>(
+  double poisson_lpdf = stan::math::reduce_sum<count_lpdf<double>>(
       data, 0.0, 5, vlambda_d, idata);
 
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
@@ -51,7 +51,7 @@ TEST(parallel_v3_reduce_sum, value) {
   ;
 }
 
-TEST(parallel_v3_reduce_sum, gradient) {
+TEST(v3_reduce_sum, gradient) {
   stan::math::init_threadpool_tbb();
 
   double lambda_d = 10.0;
@@ -70,8 +70,8 @@ TEST(parallel_v3_reduce_sum, gradient) {
   std::vector<int> idata;
   std::vector<var> vlambda_v(1, lambda_v);
 
-  var poisson_lpdf = stan::math::parallel_reduce_sum<count_lpdf<var>>(
-      data, var(0.0), 5, vlambda_v, idata);
+  var poisson_lpdf = stan::math::reduce_sum<count_lpdf<var>>(data, var(0.0), 5,
+                                                             vlambda_v, idata);
 
   var lambda_ref = lambda_d;
   var poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_ref);
@@ -113,12 +113,12 @@ struct nesting_count_lpdf {
                       const std::vector<int>& sub_slice,
                       const std::vector<T>& lambda,
                       const std::vector<int>& idata) const {
-    return stan::math::parallel_reduce_sum<count_lpdf<T>>(sub_slice, T(0.0), 5,
-                                                          lambda, idata);
+    return stan::math::reduce_sum<count_lpdf<T>>(sub_slice, T(0.0), 5, lambda,
+                                                 idata);
   }
 };
 
-TEST(parallel_v3_reduce_sum, nesting_value) {
+TEST(v3_reduce_sum, nesting_value) {
   stan::math::init_threadpool_tbb();
 
   double lambda_d = 10.0;
@@ -134,7 +134,7 @@ TEST(parallel_v3_reduce_sum, nesting_value) {
 
   typedef boost::counting_iterator<std::size_t> count_iter;
 
-  double poisson_lpdf = stan::math::parallel_reduce_sum<count_lpdf<double>>(
+  double poisson_lpdf = stan::math::reduce_sum<count_lpdf<double>>(
       data, 0.0, 5, vlambda_d, idata);
 
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
@@ -148,7 +148,7 @@ TEST(parallel_v3_reduce_sum, nesting_value) {
   ;
 }
 
-TEST(parallel_v3_reduce_sum, nesting_gradient) {
+TEST(v3_reduce_sum, nesting_gradient) {
   stan::math::init_threadpool_tbb();
 
   double lambda_d = 10.0;
@@ -167,7 +167,7 @@ TEST(parallel_v3_reduce_sum, nesting_gradient) {
   std::vector<int> idata;
   std::vector<var> vlambda_v(1, lambda_v);
 
-  var poisson_lpdf = stan::math::parallel_reduce_sum<nesting_count_lpdf<var>>(
+  var poisson_lpdf = stan::math::reduce_sum<nesting_count_lpdf<var>>(
       data, var(0.0), 5, vlambda_v, idata);
 
   var lambda_ref = lambda_d;
@@ -220,7 +220,7 @@ struct grouped_count_lpdf {
   }
 };
 
-TEST(parallel_v3_reduce_sum, grouped_gradient) {
+TEST(v3_reduce_sum, grouped_gradient) {
   stan::math::init_threadpool_tbb();
 
   double lambda_d = 10.0;
@@ -246,7 +246,7 @@ TEST(parallel_v3_reduce_sum, grouped_gradient) {
 
   var lambda_v = vlambda_v[0];
 
-  var poisson_lpdf = stan::math::parallel_reduce_sum<grouped_count_lpdf<var>>(
+  var poisson_lpdf = stan::math::reduce_sum<grouped_count_lpdf<var>>(
       data, var(0.0), 5, vlambda_v, gidx);
 
   std::vector<var> vref_lambda_v;

From 2a370e73b5a22cf3c9c8f5f2d815a32db80a456a Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Sun, 5 Jan 2020 15:28:38 +0100
Subject: [PATCH 017/189] add up to 4 arguments for reduce function

---
 stan/math/prim/meta/broadcast_array.hpp       |   1 +
 stan/math/prim/scal/functor/reduce_sum.hpp    |  79 +++++-------
 stan/math/rev/scal/functor/reduce_sum.hpp     | 114 +++++++++++++-----
 .../functor/parallel_v3_reduce_sum_test.cpp   |  93 +++++++++++++-
 4 files changed, 207 insertions(+), 80 deletions(-)

diff --git a/stan/math/prim/meta/broadcast_array.hpp b/stan/math/prim/meta/broadcast_array.hpp
index 3cc07ba97a1..78a8ba06cfb 100644
--- a/stan/math/prim/meta/broadcast_array.hpp
+++ b/stan/math/prim/meta/broadcast_array.hpp
@@ -37,6 +37,7 @@ class empty_broadcast_array {
    * Not implemented so cannot be called.
    */
   T& operator[](int /*i*/);
+  T& operator[](int /*i*/) const;
 
   /** \ingroup type_trait
    * Not implemented so cannot be called.
diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index 333e5ef6170..a1563ce70f7 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -21,32 +21,42 @@ namespace internal {
 
 // base definition => compile error
 template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
-          class T_return_type>
+          class Arg3, class Arg4, class T_return_type>
 struct reduce_sum_impl {};
 
-template <class ReduceFunction, class M, class T, class Arg1, class Arg2>
-struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, double> {
+template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
+          class Arg3, class Arg4>
+struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, double> {
   using vmapped_t = std::vector<M>;
   using arg1_t = std::vector<Arg1>;
   using arg2_t = std::vector<Arg2>;
+  using arg3_t = std::vector<Arg3>;
+  using arg4_t = std::vector<Arg4>;
 
   struct recursive_reducer {
     const vmapped_t& vmapped_;
     const arg1_t& arg1_;
     const arg2_t& arg2_;
+    const arg3_t& arg3_;
+    const arg4_t& arg4_;
     T terms_sum_;
 
     recursive_reducer(const vmapped_t& vmapped, const T& init,
-                      const arg1_t& arg1, const arg2_t& arg2)
+                      const arg1_t& arg1, const arg2_t& arg2,
+                      const arg3_t& arg3, const arg4_t& arg4, )
         : vmapped_(vmapped),
           arg1_(arg1),
           arg2_(arg2),
+          arg3_(arg3),
+          arg4_(arg4),
           terms_sum_(value_of(init)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
         : vmapped_(other.vmapped_),
           arg1_(other.arg1_),
           arg2_(other.arg2_),
+          arg3_(other.arg3_),
+          arg4_(other.arg4_),
           terms_sum_(0.0) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
@@ -58,10 +68,10 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, double> {
       auto end = vmapped_.begin();
       std::advance(end, r.end());
 
-      vmapped_t sub_slice(start, end);
+      const vmapped_t sub_slice(start, end);
 
-      terms_sum_
-          += ReduceFunction()(r.begin(), r.end() - 1, sub_slice, arg1_, arg2_);
+      terms_sum_ += ReduceFunction()(r.begin(), r.end() - 1, sub_slice, arg1_,
+                                     arg2_, arg3_, arg4_);
     }
 
     void join(const recursive_reducer& child) {
@@ -70,9 +80,10 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, double> {
   };
 
   T operator()(const vmapped_t& vmapped, T init, std::size_t grainsize,
-               const arg1_t& arg1, const arg2_t& arg2) const {
+               const arg1_t& arg1, const arg2_t& arg2, const arg3_t& arg3,
+               const arg4_t& arg4) const {
     const std::size_t num_jobs = vmapped.size();
-    recursive_reducer worker(vmapped, init, arg1, arg2);
+    recursive_reducer worker(vmapped, init, arg1, arg2, arg3, arg4);
     tbb::parallel_reduce(
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
     return std::move(worker.terms_sum_);
@@ -81,54 +92,22 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, double> {
 }  // namespace internal
 
 /*
- * The ReduceFunction is expected to have an operator with the
- * signature
- *
- * inline T operator()(std::size_t start, std::size_t end,
- *                     std::vector<int>& sub_slice, std::vector<T>& lambda,
- *                     const std::vector<int>& gidx) const
- *
- * So the input data is sliced into smaller pieces and given into the
- * reducer. Which exact sub-slice is given to the function is defined
- * by start and end index. These can be used to map data to groups,
- * for example. It would be good to extend this signature in two ways:
- *
- * 1. The large std::vector which is sliced into smaller pieces should
- *    be allowed to be any data (so int, double, vectors, matrices,
- *    ...). In a second step this should also be extended to vars
- *    which will require more considerations, but is beneficial. One
- *    could leave this generalization to a future version.
- *
- * 2. The arguments past sub_slice should be variable. So the
- *    arguments past sub_slice would need to be represented by the
- *    "..." thing in C++. The complication for this is managing all
- *    the calls.
- *
- * So the reduce_sum signature should look like
- *
- * template <class ReduceFunction, class InputIt, class T, ...>
- * constexpr T reduce_sum(InputIt first, InputIt last, T init,
- *                                std::size_t grainsize, ...)
- *
- * which corresponds to a ReduceFunction which looks like
- *
- * inline T operator()(std::size_t start, std::size_t end,
- *                     std::vector<InputIt*>& sub_slice, ...)
- *
  * Note that the ReduceFunction is only passed in as type to prohibit
  * that any internal state of the functor is causing trouble. Thus,
  * the functor must be default constructible without any arguments.
  *
  */
-template <class ReduceFunction, class M, class T, class Arg1, class Arg2>
+template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
+          class Arg3, class Arg4>
 constexpr T reduce_sum(const std::vector<M>& vmapped, T init,
-                                std::size_t grainsize,
-                                const std::vector<Arg1>& arg1,
-                                const std::vector<Arg2>& arg2) {
+                       std::size_t grainsize, const std::vector<Arg1>& arg1,
+                       const std::vector<Arg2>& arg2,
+                       const std::vector<Arg3>& arg3,
+                       const std::vector<Arg4>& arg4) {
   typedef T return_base_t;
-  return internal::reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2,
-                                            return_base_t>()(
-      vmapped, init, grainsize, arg1, arg2);
+  return internal::reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4,
+                                   return_base_t>()(vmapped, init, grainsize,
+                                                    arg1, arg2, arg3, arg4);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/scal/functor/reduce_sum.hpp b/stan/math/rev/scal/functor/reduce_sum.hpp
index df59c1d458b..f0d26989a69 100644
--- a/stan/math/rev/scal/functor/reduce_sum.hpp
+++ b/stan/math/rev/scal/functor/reduce_sum.hpp
@@ -22,10 +22,28 @@ struct child_type<int> {
   using type = int;
 };
 
+template <typename T>
+typename child_type<T>::type adjoint_of(const T x) {
+  return typename child_type<T>::type(0);
+}
+
+template <typename T>
+std::vector<typename child_type<T>::type> adjoint_of(const std::vector<T>& x) {
+  const size_t size = x.size();
+  std::vector<typename child_type<T>::type> result(size);
+  for (size_t i = 0; i != size; ++i) {
+    result[i] = adjoint_of(x[i]);
+  }
+  return result;
+}
+
+double adjoint_of(const var& x) { return x.vi_->adj_; }
+
 namespace internal {
 
-template <class ReduceFunction, class M, class T, class Arg1, class Arg2>
-struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, var> {
+template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
+          class Arg3, class Arg4>
+struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
   using vmapped_t = std::vector<M>;
   using arg1_t = std::vector<Arg1>;
   using arg2_t = std::vector<Arg2>;
@@ -33,9 +51,12 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, var> {
   using vmapped_value_t = std::vector<typename child_type<M>::type>;
   using arg1_value_t = std::vector<typename child_type<Arg1>::type>;
   using arg2_value_t = std::vector<typename child_type<Arg2>::type>;
+  using arg3_value_t = std::vector<typename child_type<Arg3>::type>;
+  using arg4_value_t = std::vector<typename child_type<Arg4>::type>;
 
   using ops_partials_t
-      = operands_and_partials<vmapped_t, std::vector<Arg1>, std::vector<Arg2>>;
+      = operands_and_partials<vmapped_t, std::vector<Arg1>, std::vector<Arg2>,
+                              std::vector<Arg3>, std::vector<Arg4>>;
 
   struct recursive_reducer {
     const vmapped_t& vmapped_;
@@ -43,6 +64,10 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, var> {
     const arg1_value_t& arg1_value_;
     const arg2_t& arg2_;
     const arg2_value_t& arg2_value_;
+    const arg3_t& arg3_;
+    const arg3_value_t& arg3_value_;
+    const arg4_t& arg4_;
+    const arg4_value_t& arg4_value_;
 
     ops_partials_t& terms_partials_mapped_;
     ops_partials_t terms_partials_args_;
@@ -51,14 +76,20 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, var> {
     recursive_reducer(const vmapped_t& vmapped, const T& init,
                       const arg1_t& arg1, const arg1_value_t& arg1_value,
                       const arg2_t& arg2, const arg2_value_t& arg2_value,
+                      const arg3_t& arg3, const arg3_value_t& arg3_value,
+                      const arg4_t& arg4, const arg4_value_t& arg4_value,
                       ops_partials_t& terms_partials_mapped)
         : vmapped_(vmapped),
           arg1_(arg1),
           arg1_value_(arg1_value),
           arg2_(arg2),
           arg2_value_(arg2_value),
+          arg3_(arg3),
+          arg3_value_(arg3_value),
+          arg4_(arg4),
+          arg4_value_(arg4_value),
           terms_partials_mapped_(terms_partials_mapped),
-          terms_partials_args_(vmapped, arg1, arg2),
+          terms_partials_args_(vmapped, arg1, arg2, arg3, arg4),
           terms_sum_(value_of(init)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
@@ -67,8 +98,12 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, var> {
           arg1_value_(other.arg1_value_),
           arg2_(other.arg2_),
           arg2_value_(other.arg2_value_),
+          arg3_(other.arg3_),
+          arg3_value_(other.arg3_value_),
+          arg4_(other.arg4_),
+          arg4_value_(other.arg4_value_),
           terms_partials_mapped_(other.terms_partials_mapped_),
-          terms_partials_args_(vmapped_, arg1_, arg2_),
+          terms_partials_args_(vmapped_, arg1_, arg2_, arg3_, arg4_),
           terms_sum_(0.0) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
@@ -107,37 +142,45 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, var> {
         // const std::vector<double> varg1_d = value_of(varg1_);
         // std::vector<Arg1> varg1(varg1_d.begin(), varg1_d.end());
 
-        arg1_t local_arg1(arg1_value_.begin(), arg1_value_.end());
-        arg2_t local_arg2(arg2_value_.begin(), arg2_value_.end());
+        const arg1_t local_arg1(arg1_value_.begin(), arg1_value_.end());
+        const arg2_t local_arg2(arg2_value_.begin(), arg2_value_.end());
+        const arg3_t local_arg3(arg3_value_.begin(), arg3_value_.end());
+        const arg4_t local_arg4(arg4_value_.begin(), arg4_value_.end());
 
-        T sub_sum_v = ReduceFunction()(r.begin(), r.end() - 1, local_sub_slice,
-                                       local_arg1, local_arg2);
+        T sub_sum_v
+            = ReduceFunction()(r.begin(), r.end() - 1, local_sub_slice,
+                               local_arg1, local_arg2, local_arg3, local_arg4);
 
         sub_sum_v.grad();
 
         terms_sum_ += sub_sum_v.val();
 
-        /*
         if (!is_constant_all<M>::value) {
+          vmapped_value_t sub_slice_adjoint = adjoint_of(local_sub_slice);
           for (std::size_t i = 0; i != r.size(); ++i)
             terms_partials_mapped_.edge1_.partials_[r.begin() + i]
-                += local_sub_slice[i].adj();
+                += sub_slice_adjoint[i];
         }
-        */
-
-        /**/
         if (!is_constant_all<Arg1>::value) {
+          arg1_value_t arg1_adjoint = adjoint_of(local_arg1);
           for (std::size_t i = 0; i != local_arg1.size(); ++i)
-            terms_partials_args_.edge2_.partials_[i] += local_arg1[i].adj();
+            terms_partials_args_.edge2_.partials_[i] += arg1_adjoint[i];
         }
-        /**/
-
-        /*
         if (!is_constant_all<Arg2>::value) {
+          arg2_value_t arg2_adjoint = adjoint_of(local_arg2);
           for (std::size_t i = 0; i != local_arg2.size(); ++i)
-            terms_partials_args_.edge3_.partials_[i] += local_arg2[i].adj();
+            terms_partials_args_.edge3_.partials_[i] += arg2_adjoint[i];
+        }
+        if (!is_constant_all<Arg3>::value) {
+          arg3_value_t arg3_adjoint = adjoint_of(local_arg1);
+          for (std::size_t i = 0; i != local_arg3.size(); ++i)
+            terms_partials_args_.edge4_.partials_[i] += arg3_adjoint[i];
+        }
+        if (!is_constant_all<Arg4>::value) {
+          arg4_value_t arg4_adjoint = adjoint_of(local_arg4);
+          for (std::size_t i = 0; i != local_arg2.size(); ++i)
+            terms_partials_args_.edge5_.partials_[i] += arg2_adjoint[i];
         }
-        */
 
       } catch (const std::exception& e) {
         recover_memory_nested();
@@ -149,34 +192,42 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, var> {
     void join(const recursive_reducer& child) {
       terms_sum_ += child.terms_sum_;
 
-      /**/
       if (!is_constant_all<Arg1>::value) {
         for (std::size_t i = 0; i != arg1_.size(); ++i)
           terms_partials_args_.edge2_.partials_[i]
               += child.terms_partials_args_.edge2_.partials_[i];
       }
-      /**/
-
-      /*
       if (!is_constant_all<Arg2>::value) {
         for (std::size_t i = 0; i != arg2_.size(); ++i)
           terms_partials_args_.edge3_.partials_[i]
               += child.terms_partials_args_.edge3_.partials_[i];
       }
-      */
+      if (!is_constant_all<Arg3>::value) {
+        for (std::size_t i = 0; i != arg3_.size(); ++i)
+          terms_partials_args_.edge4_.partials_[i]
+              += child.terms_partials_args_.edge4_.partials_[i];
+      }
+      if (!is_constant_all<Arg4>::value) {
+        for (std::size_t i = 0; i != arg4_.size(); ++i)
+          terms_partials_args_.edge5_.partials_[i]
+              += child.terms_partials_args_.edge5_.partials_[i];
+      }
     }
   };
 
   T operator()(const vmapped_t& vmapped, T init, std::size_t grainsize,
-               const arg1_t& arg1, const arg2_t& arg2) const {
+               const arg1_t& arg1, const arg2_t& arg2, const arg3_t& arg3,
+               const arg4_t& arg4) const {
     const std::size_t num_jobs = vmapped.size();
     arg1_value_t arg1_value = value_of(arg1);
     arg2_value_t arg2_value = value_of(arg2);
+    arg3_value_t arg3_value = value_of(arg3);
+    arg4_value_t arg4_value = value_of(arg4);
 
-    ops_partials_t ops(vmapped, arg1, arg2);
+    ops_partials_t ops(vmapped, arg1, arg2, arg3, arg4);
 
     recursive_reducer worker(vmapped, init, arg1, arg1_value, arg2, arg2_value,
-                             ops);
+                             arg3, arg3_value, arg4, arg4_value, ops);
 
     tbb::parallel_reduce(
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
@@ -184,10 +235,15 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, var> {
     if (!is_constant_all<Arg1>::value) {
       ops.edge2_.partials_ = worker.terms_partials_args_.edge2_.partials_;
     }
-
     if (!is_constant_all<Arg2>::value) {
       ops.edge3_.partials_ = worker.terms_partials_args_.edge3_.partials_;
     }
+    if (!is_constant_all<Arg3>::value) {
+      ops.edge4_.partials_ = worker.terms_partials_args_.edge4_.partials_;
+    }
+    if (!is_constant_all<Arg4>::value) {
+      ops.edge5_.partials_ = worker.terms_partials_args_.edge5_.partials_;
+    }
 
     return ops.build(worker.terms_sum_);
   }
diff --git a/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
index d879aa04d21..f12c87651b9 100644
--- a/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/scal/functor/parallel_v3_reduce_sum_test.cpp
@@ -208,7 +208,8 @@ struct grouped_count_lpdf {
 
   // does the reduction in the sub-slice start to end
   inline T operator()(std::size_t start, std::size_t end,
-                      std::vector<int>& sub_slice, std::vector<T>& lambda,
+                      const std::vector<int>& sub_slice,
+                      const std::vector<T>& lambda,
                       const std::vector<int>& gidx) const {
     const std::size_t num_terms = end - start + 1;
     // std::cout << "sub-slice " << start << " - " << end << "; num_terms = " <<
@@ -280,3 +281,93 @@ TEST(v3_reduce_sum, grouped_gradient) {
   ;
   stan::math::recover_memory();
 }
+
+// ********************************
+// slice over the grouping variable which is a var
+// ********************************
+
+template <typename T>
+struct slice_group_count_lpdf {
+  slice_group_count_lpdf() {}
+
+  // does the reduction in the sub-slice start to end
+  inline T operator()(std::size_t start, std::size_t end,
+                      const std::vector<T>& lambda_slice,
+                      const std::vector<int>& y,
+                      const std::vector<int>& gsidx) const {
+    const std::size_t num_groups = end - start + 1;
+    T result = 0.0;
+    for (std::size_t i = 0; i != num_groups; ++i) {
+      std::vector<int> y_group(y.begin() + gsidx[start + i],
+                               y.begin() + gsidx[start + i + 1]);
+      result += stan::math::poisson_lpmf(y_group, lambda_slice[i]);
+    }
+    return result;
+  }
+};
+
+TEST(v3_reduce_sum, slice_group_gradient) {
+  stan::math::init_threadpool_tbb();
+
+  double lambda_d = 10.0;
+  const std::size_t groups = 10;
+  const std::size_t elems_per_group = 1000;
+  const std::size_t elems = groups * elems_per_group;
+  const std::size_t num_iter = 1000;
+
+  std::vector<int> data(elems);
+  std::vector<int> gidx(elems);
+  std::vector<int> gsidx(groups + 1);
+
+  for (std::size_t i = 0, k = 0; i != groups; ++i) {
+    gsidx[i] = k;
+    for (std::size_t j = 0; j != elems_per_group; ++j, ++k) {
+      data[k] = k;
+      gidx[k] = i;
+    }
+    gsidx[i + 1] = k;
+  }
+
+  using stan::math::var;
+
+  std::vector<var> vlambda_v;
+
+  for (std::size_t i = 0; i != groups; ++i)
+    vlambda_v.push_back(i + 0.2);
+
+  var lambda_v = vlambda_v[0];
+
+  var poisson_lpdf = stan::math::reduce_sum<slice_group_count_lpdf<var>>(
+      vlambda_v, var(0.0), 5, data, gsidx);
+
+  std::vector<var> vref_lambda_v;
+  for (std::size_t i = 0; i != elems; ++i) {
+    vref_lambda_v.push_back(vlambda_v[gidx[i]]);
+  }
+  var lambda_ref = vlambda_v[0];
+
+  var poisson_lpdf_ref = stan::math::poisson_lpmf(data, vref_lambda_v);
+
+  EXPECT_FLOAT_EQ(value_of(poisson_lpdf), value_of(poisson_lpdf_ref));
+
+  stan::math::grad(poisson_lpdf_ref.vi_);
+  const double lambda_ref_adj = lambda_ref.adj();
+
+  stan::math::set_zero_all_adjoints();
+  stan::math::grad(poisson_lpdf.vi_);
+  const double lambda_adj = lambda_v.adj();
+
+  EXPECT_FLOAT_EQ(lambda_adj, lambda_ref_adj);
+
+  std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref.val()
+            << std::endl;
+  ;
+  std::cout << "ref gradient wrt to lambda: " << lambda_ref_adj << std::endl;
+  ;
+
+  std::cout << "value of poisson lpdf : " << poisson_lpdf.val() << std::endl;
+  ;
+  std::cout << "gradient wrt to lambda: " << lambda_adj << std::endl;
+  ;
+  stan::math::recover_memory();
+}

From bd1390701ea91858cb5177baf1101d139c6bdd72 Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Sun, 5 Jan 2020 15:52:30 +0100
Subject: [PATCH 018/189] make arguments optional

---
 stan/math/prim/scal/functor/reduce_sum.hpp | 124 ++++++++++++++++++++-
 stan/math/rev/scal/functor/reduce_sum.hpp  |   6 +-
 2 files changed, 124 insertions(+), 6 deletions(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index a1563ce70f7..6aa48d1d704 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -43,7 +43,7 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, double> {
 
     recursive_reducer(const vmapped_t& vmapped, const T& init,
                       const arg1_t& arg1, const arg2_t& arg2,
-                      const arg3_t& arg3, const arg4_t& arg4, )
+                      const arg3_t& arg3, const arg4_t& arg4)
         : vmapped_(vmapped),
           arg1_(arg1),
           arg2_(arg2),
@@ -89,6 +89,76 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, double> {
     return std::move(worker.terms_sum_);
   }
 };
+
+// default gives a compile time error
+template <class ReduceFunction, int optional_args>
+struct reduce_function_arg_adapter {};
+
+template <class ReduceFunction>
+struct reduce_function_arg_adapter<ReduceFunction, 4> {
+  template <class M, class Arg1, class Arg2, class Arg3, class Arg4>
+  inline auto operator()(std::size_t start, std::size_t end,
+                         const std::vector<M>& vmapped_slice,
+                         const std::vector<Arg1>& arg1,
+                         const std::vector<Arg2>& arg2,
+                         const std::vector<Arg3>& arg3,
+                         const std::vector<Arg4>& arg4) {
+    return ReduceFunction()(start, end, vmapped_slice, arg1, arg2, arg3, arg4);
+  }
+};
+
+template <class ReduceFunction>
+struct reduce_function_arg_adapter<ReduceFunction, 3> {
+  template <class M, class Arg1, class Arg2, class Arg3, class Arg4>
+  inline auto operator()(std::size_t start, std::size_t end,
+                         const std::vector<M>& vmapped_slice,
+                         const std::vector<Arg1>& arg1,
+                         const std::vector<Arg2>& arg2,
+                         const std::vector<Arg3>& arg3,
+                         const std::vector<Arg4>& arg4) {
+    return ReduceFunction()(start, end, vmapped_slice, arg1, arg2, arg3);
+  }
+};
+
+template <class ReduceFunction>
+struct reduce_function_arg_adapter<ReduceFunction, 2> {
+  template <class M, class Arg1, class Arg2, class Arg3, class Arg4>
+  inline auto operator()(std::size_t start, std::size_t end,
+                         const std::vector<M>& vmapped_slice,
+                         const std::vector<Arg1>& arg1,
+                         const std::vector<Arg2>& arg2,
+                         const std::vector<Arg3>& arg3,
+                         const std::vector<Arg4>& arg4) {
+    return ReduceFunction()(start, end, vmapped_slice, arg1, arg2);
+  }
+};
+
+template <class ReduceFunction>
+struct reduce_function_arg_adapter<ReduceFunction, 1> {
+  template <class M, class Arg1, class Arg2, class Arg3, class Arg4>
+  inline auto operator()(std::size_t start, std::size_t end,
+                         const std::vector<M>& vmapped_slice,
+                         const std::vector<Arg1>& arg1,
+                         const std::vector<Arg2>& arg2,
+                         const std::vector<Arg3>& arg3,
+                         const std::vector<Arg4>& arg4) {
+    return ReduceFunction()(start, end, vmapped_slice, arg1);
+  }
+};
+
+template <class ReduceFunction>
+struct reduce_function_arg_adapter<ReduceFunction, 0> {
+  template <class M, class Arg1, class Arg2, class Arg3, class Arg4>
+  inline auto operator()(std::size_t start, std::size_t end,
+                         const std::vector<M>& vmapped_slice,
+                         const std::vector<Arg1>& arg1,
+                         const std::vector<Arg2>& arg2,
+                         const std::vector<Arg3>& arg3,
+                         const std::vector<Arg4>& arg4) {
+    return ReduceFunction()(start, end, vmapped_slice);
+  }
+};
+
 }  // namespace internal
 
 /*
@@ -105,9 +175,55 @@ constexpr T reduce_sum(const std::vector<M>& vmapped, T init,
                        const std::vector<Arg3>& arg3,
                        const std::vector<Arg4>& arg4) {
   typedef T return_base_t;
-  return internal::reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4,
-                                   return_base_t>()(vmapped, init, grainsize,
-                                                    arg1, arg2, arg3, arg4);
+  return internal::reduce_sum_impl<
+      internal::reduce_function_arg_adapter<ReduceFunction, 4>, M, T, Arg1,
+      Arg2, Arg3, Arg4, return_base_t>()(vmapped, init, grainsize, arg1, arg2,
+                                         arg3, arg4);
+}
+
+template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
+          class Arg3>
+constexpr T reduce_sum(const std::vector<M>& vmapped, T init,
+                       std::size_t grainsize, const std::vector<Arg1>& arg1,
+                       const std::vector<Arg2>& arg2,
+                       const std::vector<Arg3>& arg3) {
+  typedef T return_base_t;
+  return internal::reduce_sum_impl<
+      internal::reduce_function_arg_adapter<ReduceFunction, 3>, M, T, Arg1,
+      Arg2, Arg3, int, return_base_t>()(vmapped, init, grainsize, arg1, arg2,
+                                        arg3, std::vector<int>());
+}
+
+template <class ReduceFunction, class M, class T, class Arg1, class Arg2>
+constexpr T reduce_sum(const std::vector<M>& vmapped, T init,
+                       std::size_t grainsize, const std::vector<Arg1>& arg1,
+                       const std::vector<Arg2>& arg2) {
+  typedef T return_base_t;
+  return internal::reduce_sum_impl<
+      internal::reduce_function_arg_adapter<ReduceFunction, 2>, M, T, Arg1,
+      Arg2, int, int, return_base_t>()(vmapped, init, grainsize, arg1, arg2,
+                                       std::vector<int>(), std::vector<int>());
+}
+template <class ReduceFunction, class M, class T, class Arg1>
+constexpr T reduce_sum(const std::vector<M>& vmapped, T init,
+                       std::size_t grainsize, const std::vector<Arg1>& arg1) {
+  typedef T return_base_t;
+  return internal::reduce_sum_impl<
+      internal::reduce_function_arg_adapter<ReduceFunction, 1>, M, T, Arg1, int,
+      int, int, return_base_t>()(vmapped, init, grainsize, arg1,
+                                 std::vector<int>(), std::vector<int>(),
+                                 std::vector<int>());
+}
+
+template <class ReduceFunction, class M, class T>
+constexpr T reduce_sum(const std::vector<M>& vmapped, T init,
+                       std::size_t grainsize) {
+  typedef T return_base_t;
+  return internal::reduce_sum_impl<
+      internal::reduce_function_arg_adapter<ReduceFunction, 0>, M, T, int, int,
+      int, int, return_base_t>()(vmapped, init, grainsize, std::vector<int>(),
+                                 std::vector<int>(), std::vector<int>(),
+                                 std::vector<int>());
 }
 
 }  // namespace math
diff --git a/stan/math/rev/scal/functor/reduce_sum.hpp b/stan/math/rev/scal/functor/reduce_sum.hpp
index f0d26989a69..943e17996bb 100644
--- a/stan/math/rev/scal/functor/reduce_sum.hpp
+++ b/stan/math/rev/scal/functor/reduce_sum.hpp
@@ -47,6 +47,8 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
   using vmapped_t = std::vector<M>;
   using arg1_t = std::vector<Arg1>;
   using arg2_t = std::vector<Arg2>;
+  using arg3_t = std::vector<Arg3>;
+  using arg4_t = std::vector<Arg4>;
 
   using vmapped_value_t = std::vector<typename child_type<M>::type>;
   using arg1_value_t = std::vector<typename child_type<Arg1>::type>;
@@ -172,14 +174,14 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
             terms_partials_args_.edge3_.partials_[i] += arg2_adjoint[i];
         }
         if (!is_constant_all<Arg3>::value) {
-          arg3_value_t arg3_adjoint = adjoint_of(local_arg1);
+          arg3_value_t arg3_adjoint = adjoint_of(local_arg3);
           for (std::size_t i = 0; i != local_arg3.size(); ++i)
             terms_partials_args_.edge4_.partials_[i] += arg3_adjoint[i];
         }
         if (!is_constant_all<Arg4>::value) {
           arg4_value_t arg4_adjoint = adjoint_of(local_arg4);
           for (std::size_t i = 0; i != local_arg2.size(); ++i)
-            terms_partials_args_.edge5_.partials_[i] += arg2_adjoint[i];
+            terms_partials_args_.edge5_.partials_[i] += arg4_adjoint[i];
         }
 
       } catch (const std::exception& e) {

From e1deb4fd1439c2d05de7fd265e506702aa77e441 Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Sun, 5 Jan 2020 16:01:07 +0100
Subject: [PATCH 019/189] more doc and const declares

---
 stan/math/prim/scal/functor/reduce_sum.hpp | 19 +++++++++++++------
 stan/math/rev/scal/functor/reduce_sum.hpp  |  8 ++++----
 2 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index 6aa48d1d704..e1ac9e6c625 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -90,6 +90,14 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, double> {
   }
 };
 
+/* The reduce_function_arg_adapter adapts the user functor to
+ * conventions used in the reduce_sum functions. While the user
+ * functor is allowed to specify optionally up to 4 additional
+ * arguments, the reduce_sum functions always expect 4
+ * arguments. Thus, the call of the reduce_sum functions with 4
+ * arguments get adapted to the user functors by dropping the
+ * arguments which are not used.
+ */
 // default gives a compile time error
 template <class ReduceFunction, int optional_args>
 struct reduce_function_arg_adapter {};
@@ -102,7 +110,7 @@ struct reduce_function_arg_adapter<ReduceFunction, 4> {
                          const std::vector<Arg1>& arg1,
                          const std::vector<Arg2>& arg2,
                          const std::vector<Arg3>& arg3,
-                         const std::vector<Arg4>& arg4) {
+                         const std::vector<Arg4>& arg4) const {
     return ReduceFunction()(start, end, vmapped_slice, arg1, arg2, arg3, arg4);
   }
 };
@@ -115,7 +123,7 @@ struct reduce_function_arg_adapter<ReduceFunction, 3> {
                          const std::vector<Arg1>& arg1,
                          const std::vector<Arg2>& arg2,
                          const std::vector<Arg3>& arg3,
-                         const std::vector<Arg4>& arg4) {
+                         const std::vector<Arg4>& arg4) const {
     return ReduceFunction()(start, end, vmapped_slice, arg1, arg2, arg3);
   }
 };
@@ -128,7 +136,7 @@ struct reduce_function_arg_adapter<ReduceFunction, 2> {
                          const std::vector<Arg1>& arg1,
                          const std::vector<Arg2>& arg2,
                          const std::vector<Arg3>& arg3,
-                         const std::vector<Arg4>& arg4) {
+                         const std::vector<Arg4>& arg4) const {
     return ReduceFunction()(start, end, vmapped_slice, arg1, arg2);
   }
 };
@@ -141,7 +149,7 @@ struct reduce_function_arg_adapter<ReduceFunction, 1> {
                          const std::vector<Arg1>& arg1,
                          const std::vector<Arg2>& arg2,
                          const std::vector<Arg3>& arg3,
-                         const std::vector<Arg4>& arg4) {
+                         const std::vector<Arg4>& arg4) const {
     return ReduceFunction()(start, end, vmapped_slice, arg1);
   }
 };
@@ -154,7 +162,7 @@ struct reduce_function_arg_adapter<ReduceFunction, 0> {
                          const std::vector<Arg1>& arg1,
                          const std::vector<Arg2>& arg2,
                          const std::vector<Arg3>& arg3,
-                         const std::vector<Arg4>& arg4) {
+                         const std::vector<Arg4>& arg4) const {
     return ReduceFunction()(start, end, vmapped_slice);
   }
 };
@@ -165,7 +173,6 @@ struct reduce_function_arg_adapter<ReduceFunction, 0> {
  * Note that the ReduceFunction is only passed in as type to prohibit
  * that any internal state of the functor is causing trouble. Thus,
  * the functor must be default constructible without any arguments.
- *
  */
 template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
           class Arg3, class Arg4>
diff --git a/stan/math/rev/scal/functor/reduce_sum.hpp b/stan/math/rev/scal/functor/reduce_sum.hpp
index 943e17996bb..d90ad18769a 100644
--- a/stan/math/rev/scal/functor/reduce_sum.hpp
+++ b/stan/math/rev/scal/functor/reduce_sum.hpp
@@ -221,10 +221,10 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
                const arg1_t& arg1, const arg2_t& arg2, const arg3_t& arg3,
                const arg4_t& arg4) const {
     const std::size_t num_jobs = vmapped.size();
-    arg1_value_t arg1_value = value_of(arg1);
-    arg2_value_t arg2_value = value_of(arg2);
-    arg3_value_t arg3_value = value_of(arg3);
-    arg4_value_t arg4_value = value_of(arg4);
+    const arg1_value_t arg1_value = value_of(arg1);
+    const arg2_value_t arg2_value = value_of(arg2);
+    const arg3_value_t arg3_value = value_of(arg3);
+    const arg4_value_t arg4_value = value_of(arg4);
 
     ops_partials_t ops(vmapped, arg1, arg2, arg3, arg4);
 

From 358525cfe3fc65188dc8ff1c9def382794f52f8b Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Sun, 5 Jan 2020 16:07:42 +0100
Subject: [PATCH 020/189] doc

---
 stan/math/rev/scal/functor/reduce_sum.hpp | 26 +++--------------------
 1 file changed, 3 insertions(+), 23 deletions(-)

diff --git a/stan/math/rev/scal/functor/reduce_sum.hpp b/stan/math/rev/scal/functor/reduce_sum.hpp
index d90ad18769a..801938bd5f8 100644
--- a/stan/math/rev/scal/functor/reduce_sum.hpp
+++ b/stan/math/rev/scal/functor/reduce_sum.hpp
@@ -115,35 +115,15 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
       try {
         start_nested();
 
-        // elem_t should better be a non-var!!! Otherwise we interfere
-        // with the outer AD tree as we mess with the adjoints (and
-        // right now we discard that it is a var if it would be)
+        // create a deep copy of all var's so that these are not
+        // linked to any outer AD tree
+
         vmapped_t local_sub_slice;
 
         local_sub_slice.reserve(r.size());
         for (std::size_t i = r.begin(); i != r.end(); ++i)
           local_sub_slice.emplace_back(value_of(vmapped_[i]));
 
-        // create a deep copy of arg1 which is not tied to the outer
-        // AD tree
-        // todo: these copies can be put onto a thread-local storage
-        // object such that we only create these once per thread which
-        // should significantly boost performance as many copies are
-        // avoided... this comes at the cost that the adjoints have to
-        // be zeroed "manually"
-        /* using the var_nochain_stack_ tape avoids up-propagation of chain
-        std::vector<Arg1> varg1;
-        varg1.reserve(varg1_.size());
-
-        for (Arg1& elem : varg1_)
-          varg1.emplace_back(var(new vari(elem.val(), false)));
-        */
-
-        // but this should actually do the same if we simply
-        // instantiate the var from a double representation
-        // const std::vector<double> varg1_d = value_of(varg1_);
-        // std::vector<Arg1> varg1(varg1_d.begin(), varg1_d.end());
-
         const arg1_t local_arg1(arg1_value_.begin(), arg1_value_.end());
         const arg2_t local_arg2(arg2_value_.begin(), arg2_value_.end());
         const arg3_t local_arg3(arg3_value_.begin(), arg3_value_.end());

From 5f76ca23ba48b5487bc87f6a4379bb8b4926eea8 Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Mon, 6 Jan 2020 22:15:24 +0100
Subject: [PATCH 021/189] generalize possible input data structures

---
 stan/math/prim/meta/broadcast_array.hpp       |   8 +
 stan/math/prim/meta/operands_and_partials.hpp |   1 +
 stan/math/rev/scal/functor/reduce_sum.hpp     | 263 +++++++++++++++---
 3 files changed, 227 insertions(+), 45 deletions(-)

diff --git a/stan/math/prim/meta/broadcast_array.hpp b/stan/math/prim/meta/broadcast_array.hpp
index 78a8ba06cfb..d71a2159380 100644
--- a/stan/math/prim/meta/broadcast_array.hpp
+++ b/stan/math/prim/meta/broadcast_array.hpp
@@ -16,6 +16,7 @@ class broadcast_array {
   explicit broadcast_array(T& prim) : prim_(prim) {}
 
   T& operator[](int /*i*/) { return prim_; }
+  T& operator[](int /*i*/) const { return prim_; }
 
   /** \ingroup type_trait
    * We can assign any right hand side which allows for indexing to a
@@ -27,6 +28,10 @@ class broadcast_array {
   void operator=(const Y& m) {
     prim_ = m[0];
   }
+  broadcast_array& operator=(broadcast_array other) {
+    prim_ = other.prim_;
+    return *this;
+  }
 };
 
 template <typename T, typename S>
@@ -44,6 +49,9 @@ class empty_broadcast_array {
    */
   template <typename Y>
   void operator=(const Y& /*A*/);
+
+  template <typename R>
+  void operator+=(R);
 };
 
 template <typename ViewElt, typename OpElt, int R, int C>
diff --git a/stan/math/prim/meta/operands_and_partials.hpp b/stan/math/prim/meta/operands_and_partials.hpp
index 5b312179430..470c218259f 100644
--- a/stan/math/prim/meta/operands_and_partials.hpp
+++ b/stan/math/prim/meta/operands_and_partials.hpp
@@ -38,6 +38,7 @@ template <typename ViewElt, typename Op>
 class ops_partials_edge {
  public:
   empty_broadcast_array<ViewElt, Op> partials_;
+  empty_broadcast_array<ViewElt, Op> partials_vec_;
 
   ops_partials_edge() {}
   explicit ops_partials_edge(const Op& /* op */) {}
diff --git a/stan/math/rev/scal/functor/reduce_sum.hpp b/stan/math/rev/scal/functor/reduce_sum.hpp
index 801938bd5f8..aa589df4e34 100644
--- a/stan/math/rev/scal/functor/reduce_sum.hpp
+++ b/stan/math/rev/scal/functor/reduce_sum.hpp
@@ -4,8 +4,6 @@
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/rev/mat/fun/typedefs.hpp>
 
-#include <boost/iterator/counting_iterator.hpp>
-
 #include <tbb/task_arena.h>
 #include <tbb/parallel_reduce.h>
 #include <tbb/blocked_range.h>
@@ -17,20 +15,42 @@
 namespace stan {
 namespace math {
 
+template <typename T>
+struct value_type {
+  using type = double;
+};
+
 template <>
-struct child_type<int> {
+struct value_type<int> {
   using type = int;
 };
 
+template <template <typename> class T_struct, typename T_value>
+struct value_type<T_struct<T_value>> {
+  using type = T_struct<typename value_type<T_value>::type>;
+};
+
+template <typename T_value>
+struct value_type<std::vector<T_value>> {
+  using type = std::vector<typename value_type<T_value>::type>;
+};
+
+template <typename T_value, int R, int C>
+struct value_type<Eigen::Matrix<T_value, R, C>> {
+  using type = Eigen::Matrix<typename value_type<T_value>::type, R, C>;
+};
+
+// adjoint_of grabs the adjoint of some data structure
+
 template <typename T>
-typename child_type<T>::type adjoint_of(const T x) {
-  return typename child_type<T>::type(0);
+typename value_type<T>::type adjoint_of(const T x) {
+  return typename value_type<T>::type(0);
 }
 
 template <typename T>
-std::vector<typename child_type<T>::type> adjoint_of(const std::vector<T>& x) {
+typename value_type<std::vector<T>>::type adjoint_of(const std::vector<T>& x) {
   const size_t size = x.size();
-  std::vector<typename child_type<T>::type> result(size);
+  typename value_type<std::vector<T>>::type result(size);
   for (size_t i = 0; i != size; ++i) {
     result[i] = adjoint_of(x[i]);
   }
@@ -39,8 +59,165 @@ std::vector<typename child_type<T>::type> adjoint_of(const std::vector<T>& x) {
 
 double adjoint_of(const var& x) { return x.vi_->adj_; }
 
+template <typename T, int R, int C>
+inline Eigen::Matrix<typename value_type<T>::type, R, C> adjoint_of(
+    const Eigen::Matrix<T, R, C>& M) {
+  Eigen::Matrix<typename value_type<T>::type, R, C> Md(M.rows(), M.cols());
+  for (int j = 0; j < M.cols(); j++) {
+    for (int i = 0; i < M.rows(); i++) {
+      Md(i, j) = adjoint_of(M(i, j));
+    }
+  }
+  return Md;
+}
+
+template <int R, int C>
+inline const Eigen::Matrix<double, R, C>& adjoint_of(
+    const Eigen::Matrix<double, R, C>& x) {
+  return Eigen::Matrix<double, R, C>::Zero(x.rows(), x.cols());
+}
+
+template <int R, int C>
+inline const Eigen::Matrix<int, R, C>& adjoint_of(
+    const Eigen::Matrix<int, R, C>& x) {
+  return Eigen::Matrix<int, R, C>::Zero(x.rows(), x.cols());
+}
+
+// as_value is similar to value_of... with the difference that it
+// keeps nested container structures which is not the case for
+// value_of
+
+template <typename T>
+typename value_type<T>::type as_value(const T x) {
+  return typename value_type<T>::type(x);
+}
+
+template <typename T>
+typename value_type<std::vector<T>>::type as_value(const std::vector<T>& x) {
+  const size_t size = x.size();
+  typename value_type<std::vector<T>>::type result(size);
+  for (size_t i = 0; i != size; ++i) {
+    result[i] = as_value(x[i]);
+  }
+  return result;
+}
+
+double as_value(const var& x) { return x.vi_->val_; }
+
+template <typename T, int R, int C>
+inline Eigen::Matrix<typename value_type<T>::type, R, C> as_value(
+    const Eigen::Matrix<T, R, C>& M) {
+  Eigen::Matrix<typename value_type<T>::type, R, C> Md(M.rows(), M.cols());
+  for (int j = 0; j < M.cols(); j++) {
+    for (int i = 0; i < M.rows(); i++) {
+      Md(i, j) = as_value(M(i, j));
+    }
+  }
+  return Md;
+}
+
+template <int R, int C>
+inline const Eigen::Matrix<double, R, C>& as_value(
+    const Eigen::Matrix<double, R, C>& x) {
+  return x.val();
+}
+
+template <int R, int C>
+inline const Eigen::Matrix<int, R, C>& as_value(
+    const Eigen::Matrix<int, R, C>& x) {
+  return x.val();
+}
+
 namespace internal {
 
+template <typename Op>
+void add_adjoints(ops_partials_edge<double, std::vector<Op>>& edge,
+                  const std::vector<typename value_type<Op>::type>& adjoint,
+                  std::size_t offset = 0) {
+  for (std::size_t i = 0; i != adjoint.size(); ++i)
+    edge.partials_[offset + i] += adjoint[i];
+}
+
+template <typename Op>
+void sum_adjoints(ops_partials_edge<double, std::vector<Op>>& edge1,
+                  const ops_partials_edge<double, std::vector<Op>>& edge2) {
+  for (std::size_t i = 0; i != edge1.partials_.size(); ++i)
+    edge1.partials_[i] += edge2.partials_[i];
+}
+
+template <typename Op>
+void add_adjoints(
+    ops_partials_edge<double, std::vector<std::vector<Op>>>& edge,
+    const std::vector<std::vector<typename value_type<Op>::type>>& adjoint,
+    std::size_t offset = 0) {
+  for (std::size_t i = 0; i != adjoint.size(); ++i)
+    for (std::size_t j = 0; j != adjoint[i].size(); ++j)
+      edge.partials_vec_[offset + i][j] += adjoint[i][j];
+}
+
+template <typename Op>
+void sum_adjoints(
+    ops_partials_edge<double, std::vector<std::vector<Op>>>& edge1,
+    const ops_partials_edge<double, std::vector<std::vector<Op>>>& edge2) {
+  for (std::size_t i = 0; i != edge1.partials_.size(); ++i)
+    for (std::size_t j = 0; j != edge1.partials_vec_[i].size(); ++j)
+      edge1.partials_vec_[i][j] += edge2.partials_vec_[i][j];
+}
+
+template <typename Op, int R, int C>
+void add_adjoints(
+    ops_partials_edge<double, std::vector<Eigen::Matrix<Op, R, C>>>& edge,
+    const std::vector<typename value_type<Eigen::Matrix<Op, R, C>>::type>&
+        adjoint,
+    std::size_t offset = 0) {
+  for (std::size_t i = 0; i != adjoint.size(); ++i)
+    for (std::size_t j = 0; j != adjoint[i].size(); ++j)
+      edge.partials_vec_[offset + i](j) += adjoint[i](j);
+}
+
+template <typename Op, int R, int C>
+void sum_adjoints(
+    ops_partials_edge<double, std::vector<Eigen::Matrix<Op, R, C>>>& edge1,
+    const ops_partials_edge<double, std::vector<Eigen::Matrix<Op, R, C>>>&
+        edge2) {
+  for (std::size_t i = 0; i != edge1.partials_vec_.size(); ++i)
+    for (std::size_t j = 0; j != edge1.partials_vec_[i].size(); ++j)
+      edge1.partials_vec_[i](j) += edge2.partials_vec_[i](j);
+}
+
+template <>
+void add_adjoints(ops_partials_edge<double, std::vector<int>>& edge,
+                  const std::vector<typename value_type<int>::type>& adjoint,
+                  std::size_t offset) {}
+
+template <>
+void sum_adjoints(ops_partials_edge<double, std::vector<int>>& edge1,
+                  const ops_partials_edge<double, std::vector<int>>& edge2) {}
+
+template <>
+void add_adjoints(
+    ops_partials_edge<double, std::vector<std::vector<int>>>& edge,
+    const std::vector<std::vector<typename value_type<int>::type>>& adjoint,
+    std::size_t offset) {}
+
+template <>
+void sum_adjoints(
+    ops_partials_edge<double, std::vector<std::vector<int>>>& edge1,
+    const ops_partials_edge<double, std::vector<std::vector<int>>>& edge2) {}
+
+template <int R, int C>
+void add_adjoints(
+    ops_partials_edge<double, std::vector<Eigen::Matrix<int, R, C>>>& edge,
+    const std::vector<typename value_type<Eigen::Matrix<int, R, C>>::type>&
+        adjoint,
+    std::size_t offset) {}
+
+template <int R, int C>
+void sum_adjoints(
+    ops_partials_edge<double, std::vector<Eigen::Matrix<int, R, C>>>& edge1,
+    const ops_partials_edge<double, std::vector<Eigen::Matrix<int, R, C>>>&
+        edge2) {}
+
 template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
           class Arg3, class Arg4>
 struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
@@ -50,11 +227,11 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
   using arg3_t = std::vector<Arg3>;
   using arg4_t = std::vector<Arg4>;
 
-  using vmapped_value_t = std::vector<typename child_type<M>::type>;
-  using arg1_value_t = std::vector<typename child_type<Arg1>::type>;
-  using arg2_value_t = std::vector<typename child_type<Arg2>::type>;
-  using arg3_value_t = std::vector<typename child_type<Arg3>::type>;
-  using arg4_value_t = std::vector<typename child_type<Arg4>::type>;
+  using vmapped_value_t = std::vector<typename value_type<M>::type>;
+  using arg1_value_t = std::vector<typename value_type<Arg1>::type>;
+  using arg2_value_t = std::vector<typename value_type<Arg2>::type>;
+  using arg3_value_t = std::vector<typename value_type<Arg3>::type>;
+  using arg4_value_t = std::vector<typename value_type<Arg4>::type>;
 
   using ops_partials_t
       = operands_and_partials<vmapped_t, std::vector<Arg1>, std::vector<Arg2>,
@@ -92,7 +269,7 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
           arg4_value_(arg4_value),
           terms_partials_mapped_(terms_partials_mapped),
           terms_partials_args_(vmapped, arg1, arg2, arg3, arg4),
-          terms_sum_(value_of(init)) {}
+          terms_sum_(as_value(init)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
         : vmapped_(other.vmapped_),
@@ -122,7 +299,7 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
 
         local_sub_slice.reserve(r.size());
         for (std::size_t i = r.begin(); i != r.end(); ++i)
-          local_sub_slice.emplace_back(value_of(vmapped_[i]));
+          local_sub_slice.emplace_back(as_value(vmapped_[i]));
 
         const arg1_t local_arg1(arg1_value_.begin(), arg1_value_.end());
         const arg2_t local_arg2(arg2_value_.begin(), arg2_value_.end());
@@ -139,29 +316,25 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
 
         if (!is_constant_all<M>::value) {
           vmapped_value_t sub_slice_adjoint = adjoint_of(local_sub_slice);
-          for (std::size_t i = 0; i != r.size(); ++i)
-            terms_partials_mapped_.edge1_.partials_[r.begin() + i]
-                += sub_slice_adjoint[i];
+          add_adjoints(terms_partials_mapped_.edge1_, sub_slice_adjoint,
+                       r.begin());
         }
+
         if (!is_constant_all<Arg1>::value) {
           arg1_value_t arg1_adjoint = adjoint_of(local_arg1);
-          for (std::size_t i = 0; i != local_arg1.size(); ++i)
-            terms_partials_args_.edge2_.partials_[i] += arg1_adjoint[i];
+          add_adjoints(terms_partials_args_.edge2_, arg1_adjoint);
         }
         if (!is_constant_all<Arg2>::value) {
           arg2_value_t arg2_adjoint = adjoint_of(local_arg2);
-          for (std::size_t i = 0; i != local_arg2.size(); ++i)
-            terms_partials_args_.edge3_.partials_[i] += arg2_adjoint[i];
+          add_adjoints(terms_partials_args_.edge3_, arg2_adjoint);
         }
         if (!is_constant_all<Arg3>::value) {
           arg3_value_t arg3_adjoint = adjoint_of(local_arg3);
-          for (std::size_t i = 0; i != local_arg3.size(); ++i)
-            terms_partials_args_.edge4_.partials_[i] += arg3_adjoint[i];
+          add_adjoints(terms_partials_args_.edge4_, arg3_adjoint);
         }
         if (!is_constant_all<Arg4>::value) {
           arg4_value_t arg4_adjoint = adjoint_of(local_arg4);
-          for (std::size_t i = 0; i != local_arg2.size(); ++i)
-            terms_partials_args_.edge5_.partials_[i] += arg4_adjoint[i];
+          add_adjoints(terms_partials_args_.edge5_, arg4_adjoint);
         }
 
       } catch (const std::exception& e) {
@@ -175,24 +348,20 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
       terms_sum_ += child.terms_sum_;
 
       if (!is_constant_all<Arg1>::value) {
-        for (std::size_t i = 0; i != arg1_.size(); ++i)
-          terms_partials_args_.edge2_.partials_[i]
-              += child.terms_partials_args_.edge2_.partials_[i];
+        sum_adjoints(terms_partials_args_.edge2_,
+                     child.terms_partials_args_.edge2_);
       }
       if (!is_constant_all<Arg2>::value) {
-        for (std::size_t i = 0; i != arg2_.size(); ++i)
-          terms_partials_args_.edge3_.partials_[i]
-              += child.terms_partials_args_.edge3_.partials_[i];
+        sum_adjoints(terms_partials_args_.edge3_,
+                     child.terms_partials_args_.edge3_);
       }
       if (!is_constant_all<Arg3>::value) {
-        for (std::size_t i = 0; i != arg3_.size(); ++i)
-          terms_partials_args_.edge4_.partials_[i]
-              += child.terms_partials_args_.edge4_.partials_[i];
+        sum_adjoints(terms_partials_args_.edge4_,
+                     child.terms_partials_args_.edge4_);
       }
       if (!is_constant_all<Arg4>::value) {
-        for (std::size_t i = 0; i != arg4_.size(); ++i)
-          terms_partials_args_.edge5_.partials_[i]
-              += child.terms_partials_args_.edge5_.partials_[i];
+        sum_adjoints(terms_partials_args_.edge5_,
+                     child.terms_partials_args_.edge5_);
       }
     }
   };
@@ -201,10 +370,10 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
                const arg1_t& arg1, const arg2_t& arg2, const arg3_t& arg3,
                const arg4_t& arg4) const {
     const std::size_t num_jobs = vmapped.size();
-    const arg1_value_t arg1_value = value_of(arg1);
-    const arg2_value_t arg2_value = value_of(arg2);
-    const arg3_value_t arg3_value = value_of(arg3);
-    const arg4_value_t arg4_value = value_of(arg4);
+    const arg1_value_t arg1_value = as_value(arg1);
+    const arg2_value_t arg2_value = as_value(arg2);
+    const arg3_value_t arg3_value = as_value(arg3);
+    const arg4_value_t arg4_value = as_value(arg4);
 
     ops_partials_t ops(vmapped, arg1, arg2, arg3, arg4);
 
@@ -215,16 +384,20 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
 
     if (!is_constant_all<Arg1>::value) {
-      ops.edge2_.partials_ = worker.terms_partials_args_.edge2_.partials_;
+      ops.edge2_.partials_vec_
+          = worker.terms_partials_args_.edge2_.partials_vec_;
     }
     if (!is_constant_all<Arg2>::value) {
-      ops.edge3_.partials_ = worker.terms_partials_args_.edge3_.partials_;
+      ops.edge3_.partials_vec_
+          = worker.terms_partials_args_.edge3_.partials_vec_;
     }
     if (!is_constant_all<Arg3>::value) {
-      ops.edge4_.partials_ = worker.terms_partials_args_.edge4_.partials_;
+      ops.edge4_.partials_vec_
+          = worker.terms_partials_args_.edge4_.partials_vec_;
     }
     if (!is_constant_all<Arg4>::value) {
-      ops.edge5_.partials_ = worker.terms_partials_args_.edge5_.partials_;
+      ops.edge5_.partials_vec_
+          = worker.terms_partials_args_.edge5_.partials_vec_;
     }
 
     return ops.build(worker.terms_sum_);

From d9e52765c38aa39f6a90c41b15b9b7a20dccd5ff Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Tue, 7 Jan 2020 21:29:25 +0100
Subject: [PATCH 022/189] refactor such that any data strcuture (contained in
 an array) can be used

---
 stan/math/rev/scal/functor/reduce_sum.hpp | 268 ++++++++++++----------
 1 file changed, 146 insertions(+), 122 deletions(-)

diff --git a/stan/math/rev/scal/functor/reduce_sum.hpp b/stan/math/rev/scal/functor/reduce_sum.hpp
index aa589df4e34..5baa09ef457 100644
--- a/stan/math/rev/scal/functor/reduce_sum.hpp
+++ b/stan/math/rev/scal/functor/reduce_sum.hpp
@@ -130,93 +130,82 @@ inline const Eigen::Matrix<int, R, C>& as_value(
 
 namespace internal {
 
-template <typename Op>
-void add_adjoints(ops_partials_edge<double, std::vector<Op>>& edge,
-                  const std::vector<typename value_type<Op>::type>& adjoint,
-                  std::size_t offset = 0) {
-  for (std::size_t i = 0; i != adjoint.size(); ++i)
-    edge.partials_[offset + i] += adjoint[i];
+template <typename T>
+inline void add_adjoint(T& sum, const T term) {
+  sum += term;
 }
 
-template <typename Op>
-void sum_adjoints(ops_partials_edge<double, std::vector<Op>>& edge1,
-                  const ops_partials_edge<double, std::vector<Op>>& edge2) {
-  for (std::size_t i = 0; i != edge1.partials_.size(); ++i)
-    edge1.partials_[i] += edge2.partials_[i];
+template <typename T>
+inline void add_adjoint(std::vector<T>& sum, const std::vector<T>& term,
+                        int offset = 0) {
+  const size_t size = term.size();
+  for (size_t i = 0; i != size; ++i) {
+    add_adjoint<T>(sum[offset + i], term[i]);
+  }
 }
 
-template <typename Op>
-void add_adjoints(
-    ops_partials_edge<double, std::vector<std::vector<Op>>>& edge,
-    const std::vector<std::vector<typename value_type<Op>::type>>& adjoint,
-    std::size_t offset = 0) {
-  for (std::size_t i = 0; i != adjoint.size(); ++i)
-    for (std::size_t j = 0; j != adjoint[i].size(); ++j)
-      edge.partials_vec_[offset + i][j] += adjoint[i][j];
+template <typename T, int R, int C>
+inline void add_adjoint(Eigen::Matrix<T, R, C>& sum,
+                        const Eigen::Matrix<T, R, C>& term) {
+  sum += term;
 }
 
 template <typename Op>
-void sum_adjoints(
-    ops_partials_edge<double, std::vector<std::vector<Op>>>& edge1,
-    const ops_partials_edge<double, std::vector<std::vector<Op>>>& edge2) {
-  for (std::size_t i = 0; i != edge1.partials_.size(); ++i)
-    for (std::size_t j = 0; j != edge1.partials_vec_[i].size(); ++j)
-      edge1.partials_vec_[i][j] += edge2.partials_vec_[i][j];
-}
-
-template <typename Op, int R, int C>
-void add_adjoints(
-    ops_partials_edge<double, std::vector<Eigen::Matrix<Op, R, C>>>& edge,
-    const std::vector<typename value_type<Eigen::Matrix<Op, R, C>>::type>&
-        adjoint,
+inline void add_adjoints(
+    ops_partials_edge<double, std::vector<Op>>& edge,
+    const std::vector<typename value_type<Op>::type>& adjoint,
     std::size_t offset = 0) {
   for (std::size_t i = 0; i != adjoint.size(); ++i)
-    for (std::size_t j = 0; j != adjoint[i].size(); ++j)
-      edge.partials_vec_[offset + i](j) += adjoint[i](j);
+    edge.partials_[offset + i] += adjoint[i];
 }
 
-template <typename Op, int R, int C>
-void sum_adjoints(
-    ops_partials_edge<double, std::vector<Eigen::Matrix<Op, R, C>>>& edge1,
-    const ops_partials_edge<double, std::vector<Eigen::Matrix<Op, R, C>>>&
-        edge2) {
-  for (std::size_t i = 0; i != edge1.partials_vec_.size(); ++i)
-    for (std::size_t j = 0; j != edge1.partials_vec_[i].size(); ++j)
-      edge1.partials_vec_[i](j) += edge2.partials_vec_[i](j);
+inline vari** register_operands(const var& op, vari** varis) {
+  (*varis) = op.vi_;
+  return varis + 1;
 }
 
-template <>
-void add_adjoints(ops_partials_edge<double, std::vector<int>>& edge,
-                  const std::vector<typename value_type<int>::type>& adjoint,
-                  std::size_t offset) {}
-
-template <>
-void sum_adjoints(ops_partials_edge<double, std::vector<int>>& edge1,
-                  const ops_partials_edge<double, std::vector<int>>& edge2) {}
+template <int R, int C>
+inline vari** register_operands(const Eigen::Matrix<var, R, C>& M_op,
+                                vari** varis) {
+  const size_t size = M_op.size();
+  for (size_t i = 0; i != M_op.cols(); ++i) {
+    for (size_t j = 0; j != M_op.rows(); ++j, ++varis) {
+      *varis = M_op(i, j).vi_;
+    }
+  }
+  return varis;
+}
 
-template <>
-void add_adjoints(
-    ops_partials_edge<double, std::vector<std::vector<int>>>& edge,
-    const std::vector<std::vector<typename value_type<int>::type>>& adjoint,
-    std::size_t offset) {}
+template <typename T>
+inline vari** register_operands(const std::vector<T>& op, vari** varis) {
+  const size_t size = op.size();
+  for (size_t i = 0; i != size; ++i) {
+    varis = register_operands(op[i], varis);
+  }
+  return varis;
+}
 
-template <>
-void sum_adjoints(
-    ops_partials_edge<double, std::vector<std::vector<int>>>& edge1,
-    const ops_partials_edge<double, std::vector<std::vector<int>>>& edge2) {}
+inline double* register_partials(const double grad, double* partials) {
+  (*partials) = grad;
+  return partials + 1;
+}
 
 template <int R, int C>
-void add_adjoints(
-    ops_partials_edge<double, std::vector<Eigen::Matrix<int, R, C>>>& edge,
-    const std::vector<typename value_type<Eigen::Matrix<int, R, C>>::type>&
-        adjoint,
-    std::size_t offset) {}
+inline double* register_partials(const Eigen::Matrix<double, R, C>& M_grad,
+                                 double* partials) {
+  const size_t size = M_grad.size();
+  std::copy(M_grad.data(), M_grad.data() + size, partials);
+  return partials + size;
+}
 
-template <int R, int C>
-void sum_adjoints(
-    ops_partials_edge<double, std::vector<Eigen::Matrix<int, R, C>>>& edge1,
-    const ops_partials_edge<double, std::vector<Eigen::Matrix<int, R, C>>>&
-        edge2) {}
+template <typename T>
+inline double* register_partials(const std::vector<T>& grad, double* partials) {
+  const size_t size = grad.size();
+  for (size_t i = 0; i != size; ++i) {
+    partials = register_partials(grad[i], partials);
+  }
+  return partials;
+}
 
 template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
           class Arg3, class Arg4>
@@ -233,12 +222,9 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
   using arg3_value_t = std::vector<typename value_type<Arg3>::type>;
   using arg4_value_t = std::vector<typename value_type<Arg4>::type>;
 
-  using ops_partials_t
-      = operands_and_partials<vmapped_t, std::vector<Arg1>, std::vector<Arg2>,
-                              std::vector<Arg3>, std::vector<Arg4>>;
-
   struct recursive_reducer {
     const vmapped_t& vmapped_;
+    vmapped_value_t& vmapped_adjoint_;
     const arg1_t& arg1_;
     const arg1_value_t& arg1_value_;
     const arg2_t& arg2_;
@@ -248,17 +234,23 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
     const arg4_t& arg4_;
     const arg4_value_t& arg4_value_;
 
-    ops_partials_t& terms_partials_mapped_;
-    ops_partials_t terms_partials_args_;
+    arg1_value_t arg1_adjoint_;
+    arg2_value_t arg2_adjoint_;
+    arg3_value_t arg3_adjoint_;
+    arg4_value_t arg4_adjoint_;
+
     double terms_sum_;
 
-    recursive_reducer(const vmapped_t& vmapped, const T& init,
+    recursive_reducer(const vmapped_t& vmapped,
+                      vmapped_value_t& vmapped_adjoint, const T& init,
                       const arg1_t& arg1, const arg1_value_t& arg1_value,
                       const arg2_t& arg2, const arg2_value_t& arg2_value,
                       const arg3_t& arg3, const arg3_value_t& arg3_value,
-                      const arg4_t& arg4, const arg4_value_t& arg4_value,
-                      ops_partials_t& terms_partials_mapped)
+                      const arg4_t& arg4, const arg4_value_t& arg4_value
+                      // ops_partials_t& terms_partials_mapped,
+                      )
         : vmapped_(vmapped),
+          vmapped_adjoint_(vmapped_adjoint),
           arg1_(arg1),
           arg1_value_(arg1_value),
           arg2_(arg2),
@@ -267,12 +259,19 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
           arg3_value_(arg3_value),
           arg4_(arg4),
           arg4_value_(arg4_value),
-          terms_partials_mapped_(terms_partials_mapped),
-          terms_partials_args_(vmapped, arg1, arg2, arg3, arg4),
+          arg1_adjoint_(is_constant<arg1_t>::value ? arg1_value_t()
+                                                   : adjoint_of(arg1_value)),
+          arg2_adjoint_(is_constant<arg2_t>::value ? arg2_value_t()
+                                                   : adjoint_of(arg2_value)),
+          arg3_adjoint_(is_constant<arg3_t>::value ? arg3_value_t()
+                                                   : adjoint_of(arg3_value)),
+          arg4_adjoint_(is_constant<arg4_t>::value ? arg4_value_t()
+                                                   : adjoint_of(arg4_value)),
           terms_sum_(as_value(init)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
         : vmapped_(other.vmapped_),
+          vmapped_adjoint_(other.vmapped_adjoint_),
           arg1_(other.arg1_),
           arg1_value_(other.arg1_value_),
           arg2_(other.arg2_),
@@ -281,8 +280,10 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
           arg3_value_(other.arg3_value_),
           arg4_(other.arg4_),
           arg4_value_(other.arg4_value_),
-          terms_partials_mapped_(other.terms_partials_mapped_),
-          terms_partials_args_(vmapped_, arg1_, arg2_, arg3_, arg4_),
+          arg1_adjoint_(adjoint_of(arg1_value_)),
+          arg2_adjoint_(adjoint_of(arg2_value_)),
+          arg3_adjoint_(adjoint_of(arg3_value_)),
+          arg4_adjoint_(adjoint_of(arg4_value_)),
           terms_sum_(0.0) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
@@ -316,27 +317,21 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
 
         if (!is_constant_all<M>::value) {
           vmapped_value_t sub_slice_adjoint = adjoint_of(local_sub_slice);
-          add_adjoints(terms_partials_mapped_.edge1_, sub_slice_adjoint,
-                       r.begin());
+          add_adjoint(vmapped_adjoint_, sub_slice_adjoint, r.begin());
         }
 
-        if (!is_constant_all<Arg1>::value) {
-          arg1_value_t arg1_adjoint = adjoint_of(local_arg1);
-          add_adjoints(terms_partials_args_.edge2_, arg1_adjoint);
+        if (!is_constant<Arg1>::value) {
+          add_adjoint(arg1_adjoint_, adjoint_of(local_arg1));
         }
-        if (!is_constant_all<Arg2>::value) {
-          arg2_value_t arg2_adjoint = adjoint_of(local_arg2);
-          add_adjoints(terms_partials_args_.edge3_, arg2_adjoint);
+        if (!is_constant<Arg2>::value) {
+          add_adjoint(arg2_adjoint_, adjoint_of(local_arg2));
         }
-        if (!is_constant_all<Arg3>::value) {
-          arg3_value_t arg3_adjoint = adjoint_of(local_arg3);
-          add_adjoints(terms_partials_args_.edge4_, arg3_adjoint);
+        if (!is_constant<Arg3>::value) {
+          add_adjoint(arg3_adjoint_, adjoint_of(local_arg3));
         }
-        if (!is_constant_all<Arg4>::value) {
-          arg4_value_t arg4_adjoint = adjoint_of(local_arg4);
-          add_adjoints(terms_partials_args_.edge5_, arg4_adjoint);
+        if (!is_constant<Arg4>::value) {
+          add_adjoint(arg4_adjoint_, adjoint_of(local_arg4));
         }
-
       } catch (const std::exception& e) {
         recover_memory_nested();
         throw;
@@ -348,20 +343,16 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
       terms_sum_ += child.terms_sum_;
 
       if (!is_constant_all<Arg1>::value) {
-        sum_adjoints(terms_partials_args_.edge2_,
-                     child.terms_partials_args_.edge2_);
+        add_adjoint(arg1_adjoint_, child.arg1_adjoint_);
       }
       if (!is_constant_all<Arg2>::value) {
-        sum_adjoints(terms_partials_args_.edge3_,
-                     child.terms_partials_args_.edge3_);
+        add_adjoint(arg2_adjoint_, child.arg2_adjoint_);
       }
       if (!is_constant_all<Arg3>::value) {
-        sum_adjoints(terms_partials_args_.edge4_,
-                     child.terms_partials_args_.edge4_);
+        add_adjoint(arg3_adjoint_, child.arg3_adjoint_);
       }
       if (!is_constant_all<Arg4>::value) {
-        sum_adjoints(terms_partials_args_.edge5_,
-                     child.terms_partials_args_.edge5_);
+        add_adjoint(arg4_adjoint_, child.arg4_adjoint_);
       }
     }
   };
@@ -370,37 +361,70 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
                const arg1_t& arg1, const arg2_t& arg2, const arg3_t& arg3,
                const arg4_t& arg4) const {
     const std::size_t num_jobs = vmapped.size();
+    vmapped_value_t vmapped_adjoint = adjoint_of(as_value(vmapped));
     const arg1_value_t arg1_value = as_value(arg1);
     const arg2_value_t arg2_value = as_value(arg2);
     const arg3_value_t arg3_value = as_value(arg3);
     const arg4_value_t arg4_value = as_value(arg4);
 
-    ops_partials_t ops(vmapped, arg1, arg2, arg3, arg4);
-
-    recursive_reducer worker(vmapped, init, arg1, arg1_value, arg2, arg2_value,
-                             arg3, arg3_value, arg4, arg4_value, ops);
+    recursive_reducer worker(vmapped, vmapped_adjoint, init, arg1, arg1_value,
+                             arg2, arg2_value, arg3, arg3_value, arg4,
+                             arg4_value);
 
     tbb::parallel_reduce(
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
 
-    if (!is_constant_all<Arg1>::value) {
-      ops.edge2_.partials_vec_
-          = worker.terms_partials_args_.edge2_.partials_vec_;
+    std::vector<std::size_t> num_terms_arg(5, 0);
+
+    if (!is_constant<vmapped_t>::value)
+      num_terms_arg[0] = num_elements(vmapped_adjoint);
+    if (!is_constant<Arg1>::value)
+      num_terms_arg[1] = num_elements(arg1_value);
+    if (!is_constant<Arg2>::value)
+      num_terms_arg[2] = num_elements(arg2_value);
+    if (!is_constant<Arg3>::value)
+      num_terms_arg[3] = num_elements(arg3_value);
+    if (!is_constant<Arg4>::value)
+      num_terms_arg[4] = num_elements(arg4_value);
+
+    const std::size_t num_terms = sum(num_terms_arg);
+
+    vari** varis
+        = ChainableStack::instance_->memalloc_.alloc_array<vari*>(num_terms);
+    double* partials
+        = ChainableStack::instance_->memalloc_.alloc_array<double>(num_terms);
+
+    std::size_t idx = 0;
+
+    if (!is_constant<vmapped_t>::value) {
+      register_operands(vmapped, &varis[idx]);
+      register_partials(vmapped_adjoint, &partials[idx]);
+      idx += num_terms_arg[0];
+    }
+
+    if (!is_constant<Arg1>::value) {
+      register_operands(arg1, &varis[idx]);
+      register_partials(worker.arg1_adjoint_, &partials[idx]);
+      idx += num_terms_arg[1];
     }
-    if (!is_constant_all<Arg2>::value) {
-      ops.edge3_.partials_vec_
-          = worker.terms_partials_args_.edge3_.partials_vec_;
+    if (!is_constant<Arg2>::value) {
+      register_operands(arg2, &varis[idx]);
+      register_partials(worker.arg3_adjoint_, &partials[idx]);
+      idx += num_terms_arg[2];
     }
-    if (!is_constant_all<Arg3>::value) {
-      ops.edge4_.partials_vec_
-          = worker.terms_partials_args_.edge4_.partials_vec_;
+    if (!is_constant<Arg3>::value) {
+      register_operands(arg3, &varis[idx]);
+      register_partials(worker.arg3_adjoint_, &partials[idx]);
+      idx += num_terms_arg[3];
     }
-    if (!is_constant_all<Arg4>::value) {
-      ops.edge5_.partials_vec_
-          = worker.terms_partials_args_.edge5_.partials_vec_;
+    if (!is_constant<Arg4>::value) {
+      register_operands(arg4, &varis[idx]);
+      register_partials(worker.arg4_adjoint_, &partials[idx]);
+      idx += num_terms_arg[4];
     }
 
-    return ops.build(worker.terms_sum_);
+    return var(new precomputed_gradients_vari(worker.terms_sum_, num_terms,
+                                              varis, partials));
   }
 };
 }  // namespace internal

From 5e01bf03800a725f9e05ed766a485a204d60c88e Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Tue, 7 Jan 2020 22:23:07 +0100
Subject: [PATCH 023/189] fix looping order error

---
 stan/math/rev/scal/functor/reduce_sum.hpp | 90 +++++++++++------------
 1 file changed, 43 insertions(+), 47 deletions(-)

diff --git a/stan/math/rev/scal/functor/reduce_sum.hpp b/stan/math/rev/scal/functor/reduce_sum.hpp
index 5baa09ef457..c2f2a2ca3f7 100644
--- a/stan/math/rev/scal/functor/reduce_sum.hpp
+++ b/stan/math/rev/scal/functor/reduce_sum.hpp
@@ -47,16 +47,6 @@ typename value_type<T>::type adjoint_of(const T x) {
   return typename value_type<T>::type(0);
 }
 
-template <typename T>
-typename value_type<std::vector<T>>::type adjoint_of(const std::vector<T>& x) {
-  const size_t size = x.size();
-  typename value_type<std::vector<T>>::type result(size);
-  for (size_t i = 0; i != size; ++i) {
-    result[i] = adjoint_of(x[i]);
-  }
-  return result;
-}
-
 double adjoint_of(const var& x) { return x.vi_->adj_; }
 
 template <typename T, int R, int C>
@@ -72,17 +62,26 @@ inline Eigen::Matrix<typename value_type<T>::type, R, C> adjoint_of(
 }
 
 template <int R, int C>
-inline const Eigen::Matrix<double, R, C>& adjoint_of(
+inline Eigen::Matrix<double, R, C> adjoint_of(
     const Eigen::Matrix<double, R, C>& x) {
   return Eigen::Matrix<double, R, C>::Zero(x.rows(), x.cols());
 }
 
 template <int R, int C>
-inline const Eigen::Matrix<int, R, C>& adjoint_of(
-    const Eigen::Matrix<int, R, C>& x) {
+inline Eigen::Matrix<int, R, C> adjoint_of(const Eigen::Matrix<int, R, C>& x) {
   return Eigen::Matrix<int, R, C>::Zero(x.rows(), x.cols());
 }
 
+template <typename T>
+typename value_type<std::vector<T>>::type adjoint_of(const std::vector<T>& x) {
+  const size_t size = x.size();
+  typename value_type<std::vector<T>>::type result(size);
+  for (size_t i = 0; i != size; ++i) {
+    result[i] = adjoint_of(x[i]);
+  }
+  return result;
+}
+
 // as_value is similar to value_of... with the difference that it
 // keeps nested container structures which is not the case for
 // value_of
@@ -135,28 +134,19 @@ inline void add_adjoint(T& sum, const T term) {
   sum += term;
 }
 
-template <typename T>
-inline void add_adjoint(std::vector<T>& sum, const std::vector<T>& term,
-                        int offset = 0) {
-  const size_t size = term.size();
-  for (size_t i = 0; i != size; ++i) {
-    add_adjoint<T>(sum[offset + i], term[i]);
-  }
-}
-
 template <typename T, int R, int C>
 inline void add_adjoint(Eigen::Matrix<T, R, C>& sum,
                         const Eigen::Matrix<T, R, C>& term) {
   sum += term;
 }
 
-template <typename Op>
-inline void add_adjoints(
-    ops_partials_edge<double, std::vector<Op>>& edge,
-    const std::vector<typename value_type<Op>::type>& adjoint,
-    std::size_t offset = 0) {
-  for (std::size_t i = 0; i != adjoint.size(); ++i)
-    edge.partials_[offset + i] += adjoint[i];
+template <typename T>
+inline void add_adjoint(std::vector<T>& sum, const std::vector<T>& term,
+                        int offset = 0) {
+  const size_t size = term.size();
+  for (size_t i = 0; i != size; ++i) {
+    add_adjoint(sum[offset + i], term[i]);
+  }
 }
 
 inline vari** register_operands(const var& op, vari** varis) {
@@ -170,7 +160,7 @@ inline vari** register_operands(const Eigen::Matrix<var, R, C>& M_op,
   const size_t size = M_op.size();
   for (size_t i = 0; i != M_op.cols(); ++i) {
     for (size_t j = 0; j != M_op.rows(); ++j, ++varis) {
-      *varis = M_op(i, j).vi_;
+      *varis = M_op(j, i).vi_;
     }
   }
   return varis;
@@ -259,14 +249,14 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
           arg3_value_(arg3_value),
           arg4_(arg4),
           arg4_value_(arg4_value),
-          arg1_adjoint_(is_constant<arg1_t>::value ? arg1_value_t()
-                                                   : adjoint_of(arg1_value)),
-          arg2_adjoint_(is_constant<arg2_t>::value ? arg2_value_t()
-                                                   : adjoint_of(arg2_value)),
-          arg3_adjoint_(is_constant<arg3_t>::value ? arg3_value_t()
-                                                   : adjoint_of(arg3_value)),
-          arg4_adjoint_(is_constant<arg4_t>::value ? arg4_value_t()
-                                                   : adjoint_of(arg4_value)),
+          arg1_adjoint_(is_constant<Arg1>::value ? arg1_value_t()
+                                                 : adjoint_of(arg1_value_)),
+          arg2_adjoint_(is_constant<Arg2>::value ? arg2_value_t()
+                                                 : adjoint_of(arg2_value_)),
+          arg3_adjoint_(is_constant<Arg3>::value ? arg3_value_t()
+                                                 : adjoint_of(arg3_value_)),
+          arg4_adjoint_(is_constant<Arg4>::value ? arg4_value_t()
+                                                 : adjoint_of(arg4_value_)),
           terms_sum_(as_value(init)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
@@ -315,9 +305,8 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
 
         terms_sum_ += sub_sum_v.val();
 
-        if (!is_constant_all<M>::value) {
-          vmapped_value_t sub_slice_adjoint = adjoint_of(local_sub_slice);
-          add_adjoint(vmapped_adjoint_, sub_slice_adjoint, r.begin());
+        if (!is_constant<M>::value) {
+          add_adjoint(vmapped_adjoint_, adjoint_of(local_sub_slice), r.begin());
         }
 
         if (!is_constant<Arg1>::value) {
@@ -342,16 +331,16 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
     void join(const recursive_reducer& child) {
       terms_sum_ += child.terms_sum_;
 
-      if (!is_constant_all<Arg1>::value) {
+      if (!is_constant<Arg1>::value) {
         add_adjoint(arg1_adjoint_, child.arg1_adjoint_);
       }
-      if (!is_constant_all<Arg2>::value) {
+      if (!is_constant<Arg2>::value) {
         add_adjoint(arg2_adjoint_, child.arg2_adjoint_);
       }
-      if (!is_constant_all<Arg3>::value) {
+      if (!is_constant<Arg3>::value) {
         add_adjoint(arg3_adjoint_, child.arg3_adjoint_);
       }
-      if (!is_constant_all<Arg4>::value) {
+      if (!is_constant<Arg4>::value) {
         add_adjoint(arg4_adjoint_, child.arg4_adjoint_);
       }
     }
@@ -371,12 +360,19 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
                              arg2, arg2_value, arg3, arg3_value, arg4,
                              arg4_value);
 
+#ifdef STAN_DETERMINISTIC
+    tbb::static_partitioner partitioner;
+    tbb::parallel_deterministic_reduce(
+        tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker,
+        partitioner);
+#else
     tbb::parallel_reduce(
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
+#endif
 
     std::vector<std::size_t> num_terms_arg(5, 0);
 
-    if (!is_constant<vmapped_t>::value)
+    if (!is_constant<M>::value)
       num_terms_arg[0] = num_elements(vmapped_adjoint);
     if (!is_constant<Arg1>::value)
       num_terms_arg[1] = num_elements(arg1_value);
@@ -409,7 +405,7 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
     }
     if (!is_constant<Arg2>::value) {
       register_operands(arg2, &varis[idx]);
-      register_partials(worker.arg3_adjoint_, &partials[idx]);
+      register_partials(worker.arg2_adjoint_, &partials[idx]);
       idx += num_terms_arg[2];
     }
     if (!is_constant<Arg3>::value) {

From f2ed8a9ddc82542ec853b33fe948106e411feada Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Fri, 10 Jan 2020 18:01:35 +0100
Subject: [PATCH 024/189] still struggling with performance regression

---
 stan/math/rev/scal/functor/reduce_sum.hpp | 260 +++++++++++-----------
 1 file changed, 134 insertions(+), 126 deletions(-)

diff --git a/stan/math/rev/scal/functor/reduce_sum.hpp b/stan/math/rev/scal/functor/reduce_sum.hpp
index c2f2a2ca3f7..a3a2530d813 100644
--- a/stan/math/rev/scal/functor/reduce_sum.hpp
+++ b/stan/math/rev/scal/functor/reduce_sum.hpp
@@ -197,6 +197,74 @@ inline double* register_partials(const std::vector<T>& grad, double* partials) {
   return partials;
 }
 
+template <typename T>
+struct local_operand_and_partials {
+  using Op_t = std::vector<T>;
+  using Op_value_t = std::vector<typename value_type<T>::type>;
+  // will be either a const var to get local copies or a const value&
+  // ref to avoid copying data... TODO
+  using Op_local_t = Op_value_t;
+  // using partials_t = Eigen::VectorXd;
+  using partials_t = Op_value_t;
+
+  const Op_t& op_;
+  const Op_value_t& op_value_;
+  // Op_t local_op_;
+  // std::size_t local_op_start_;
+  partials_t partials_;
+
+  explicit local_operand_and_partials(const Op_t& op,
+                                      const Op_value_t& op_value)
+      : op_(op),
+        op_value_(op_value),
+        // local_op_(),
+        // local_op_start_(0),
+        partials_(is_constant<T>::value ? Op_value_t()
+                                        : adjoint_of(op_value_)) {}
+
+  local_operand_and_partials(const local_operand_and_partials<T>& other)
+      : op_(other.op_),
+        op_value_(other.op_value_),
+        // local_op_(),
+        // local_op_start_(0),
+        partials_(is_constant<T>::value ? Op_value_t()
+                                        : adjoint_of(other.op_value_)) {}
+
+  inline void add_local_adjoint(const Op_t& local_op, std::size_t offset = 0) {
+    if (!is_constant<T>::value) {
+      add_adjoint(partials_, adjoint_of(local_op), offset);
+      // local_op_ = Op_t();
+    }
+  }
+
+  inline void add_other_adjoint(const local_operand_and_partials<T>& other) {
+    if (!is_constant<T>::value) {
+      add_adjoint(partials_, other.partials_);
+    }
+  }
+
+  inline const Op_t local_op(std::size_t start = 0, std::size_t end = -1) {
+    // local_op_start_ = start;
+    const Op_t local_op
+        = Op_t(op_value_.begin() + start,
+               (end == -1 ? op_value_.end() : op_value_.begin() + end));
+    return std::move(local_op);
+  }
+
+  inline std::size_t num_elements() {
+    if (!is_constant<T>::value)
+      return stan::math::num_elements(op_value_);
+    return 0;
+  }
+
+  inline void build(vari** varis, double* partials) {
+    if (!is_constant<T>::value) {
+      register_operands(op_, varis);
+      register_partials(partials_, partials);
+    }
+  }
+};
+
 template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
           class Arg3, class Arg4>
 struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
@@ -212,68 +280,40 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
   using arg3_value_t = std::vector<typename value_type<Arg3>::type>;
   using arg4_value_t = std::vector<typename value_type<Arg4>::type>;
 
+  using vmapped_op_t = local_operand_and_partials<M>;
+  using arg1_local_op_t = local_operand_and_partials<Arg1>;
+  using arg2_local_op_t = local_operand_and_partials<Arg2>;
+  using arg3_local_op_t = local_operand_and_partials<Arg3>;
+  using arg4_local_op_t = local_operand_and_partials<Arg4>;
+
   struct recursive_reducer {
-    const vmapped_t& vmapped_;
-    vmapped_value_t& vmapped_adjoint_;
-    const arg1_t& arg1_;
-    const arg1_value_t& arg1_value_;
-    const arg2_t& arg2_;
-    const arg2_value_t& arg2_value_;
-    const arg3_t& arg3_;
-    const arg3_value_t& arg3_value_;
-    const arg4_t& arg4_;
-    const arg4_value_t& arg4_value_;
-
-    arg1_value_t arg1_adjoint_;
-    arg2_value_t arg2_adjoint_;
-    arg3_value_t arg3_adjoint_;
-    arg4_value_t arg4_adjoint_;
+    vmapped_op_t op_vmapped_;
+    arg1_local_op_t op_arg1_;
+    arg2_local_op_t op_arg2_;
+    arg3_local_op_t op_arg3_;
+    arg4_local_op_t op_arg4_;
 
     double terms_sum_;
 
     recursive_reducer(const vmapped_t& vmapped,
-                      vmapped_value_t& vmapped_adjoint, const T& init,
+                      const vmapped_value_t& vmapped_value, const T& init,
                       const arg1_t& arg1, const arg1_value_t& arg1_value,
                       const arg2_t& arg2, const arg2_value_t& arg2_value,
                       const arg3_t& arg3, const arg3_value_t& arg3_value,
-                      const arg4_t& arg4, const arg4_value_t& arg4_value
-                      // ops_partials_t& terms_partials_mapped,
-                      )
-        : vmapped_(vmapped),
-          vmapped_adjoint_(vmapped_adjoint),
-          arg1_(arg1),
-          arg1_value_(arg1_value),
-          arg2_(arg2),
-          arg2_value_(arg2_value),
-          arg3_(arg3),
-          arg3_value_(arg3_value),
-          arg4_(arg4),
-          arg4_value_(arg4_value),
-          arg1_adjoint_(is_constant<Arg1>::value ? arg1_value_t()
-                                                 : adjoint_of(arg1_value_)),
-          arg2_adjoint_(is_constant<Arg2>::value ? arg2_value_t()
-                                                 : adjoint_of(arg2_value_)),
-          arg3_adjoint_(is_constant<Arg3>::value ? arg3_value_t()
-                                                 : adjoint_of(arg3_value_)),
-          arg4_adjoint_(is_constant<Arg4>::value ? arg4_value_t()
-                                                 : adjoint_of(arg4_value_)),
+                      const arg4_t& arg4, const arg4_value_t& arg4_value)
+        : op_vmapped_(vmapped, vmapped_value),
+          op_arg1_(arg1, arg1_value),
+          op_arg2_(arg2, arg2_value),
+          op_arg3_(arg3, arg3_value),
+          op_arg4_(arg4, arg4_value),
           terms_sum_(as_value(init)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-        : vmapped_(other.vmapped_),
-          vmapped_adjoint_(other.vmapped_adjoint_),
-          arg1_(other.arg1_),
-          arg1_value_(other.arg1_value_),
-          arg2_(other.arg2_),
-          arg2_value_(other.arg2_value_),
-          arg3_(other.arg3_),
-          arg3_value_(other.arg3_value_),
-          arg4_(other.arg4_),
-          arg4_value_(other.arg4_value_),
-          arg1_adjoint_(adjoint_of(arg1_value_)),
-          arg2_adjoint_(adjoint_of(arg2_value_)),
-          arg3_adjoint_(adjoint_of(arg3_value_)),
-          arg4_adjoint_(adjoint_of(arg4_value_)),
+        : op_vmapped_(other.op_vmapped_),
+          op_arg1_(other.op_arg1_),
+          op_arg2_(other.op_arg2_),
+          op_arg3_(other.op_arg3_),
+          op_arg4_(other.op_arg4_),
           terms_sum_(0.0) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
@@ -286,41 +326,38 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
         // create a deep copy of all var's so that these are not
         // linked to any outer AD tree
 
-        vmapped_t local_sub_slice;
+        const vmapped_t local_sub_slice
+            = op_vmapped_.local_op(r.begin(), r.end());
 
-        local_sub_slice.reserve(r.size());
-        for (std::size_t i = r.begin(); i != r.end(); ++i)
-          local_sub_slice.emplace_back(as_value(vmapped_[i]));
-
-        const arg1_t local_arg1(arg1_value_.begin(), arg1_value_.end());
-        const arg2_t local_arg2(arg2_value_.begin(), arg2_value_.end());
-        const arg3_t local_arg3(arg3_value_.begin(), arg3_value_.end());
-        const arg4_t local_arg4(arg4_value_.begin(), arg4_value_.end());
+        const arg1_t local_arg1 = op_arg1_.local_op();
+        const arg2_t local_arg2 = op_arg2_.local_op();
+        const arg3_t local_arg3 = op_arg3_.local_op();
+        const arg4_t local_arg4 = op_arg4_.local_op();
 
         T sub_sum_v
             = ReduceFunction()(r.begin(), r.end() - 1, local_sub_slice,
                                local_arg1, local_arg2, local_arg3, local_arg4);
 
+        /*
+        T sub_sum_v
+            = ReduceFunction()(r.begin(), r.end() - 1,
+                               op_vmapped_.local_op(r.begin(), r.end()),
+                               op_arg1_.local_op(),
+                               op_arg2_.local_op(),
+                               op_arg3_.local_op(),
+                               op_arg4_.local_op());
+        */
         sub_sum_v.grad();
 
         terms_sum_ += sub_sum_v.val();
 
-        if (!is_constant<M>::value) {
-          add_adjoint(vmapped_adjoint_, adjoint_of(local_sub_slice), r.begin());
-        }
-
-        if (!is_constant<Arg1>::value) {
-          add_adjoint(arg1_adjoint_, adjoint_of(local_arg1));
-        }
-        if (!is_constant<Arg2>::value) {
-          add_adjoint(arg2_adjoint_, adjoint_of(local_arg2));
-        }
-        if (!is_constant<Arg3>::value) {
-          add_adjoint(arg3_adjoint_, adjoint_of(local_arg3));
-        }
-        if (!is_constant<Arg4>::value) {
-          add_adjoint(arg4_adjoint_, adjoint_of(local_arg4));
-        }
+        op_vmapped_.add_local_adjoint(local_sub_slice, r.begin());
+
+        op_arg1_.add_local_adjoint(local_arg1);
+        op_arg2_.add_local_adjoint(local_arg2);
+        op_arg3_.add_local_adjoint(local_arg3);
+        op_arg4_.add_local_adjoint(local_arg4);
+
       } catch (const std::exception& e) {
         recover_memory_nested();
         throw;
@@ -331,18 +368,10 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
     void join(const recursive_reducer& child) {
       terms_sum_ += child.terms_sum_;
 
-      if (!is_constant<Arg1>::value) {
-        add_adjoint(arg1_adjoint_, child.arg1_adjoint_);
-      }
-      if (!is_constant<Arg2>::value) {
-        add_adjoint(arg2_adjoint_, child.arg2_adjoint_);
-      }
-      if (!is_constant<Arg3>::value) {
-        add_adjoint(arg3_adjoint_, child.arg3_adjoint_);
-      }
-      if (!is_constant<Arg4>::value) {
-        add_adjoint(arg4_adjoint_, child.arg4_adjoint_);
-      }
+      op_arg1_.add_other_adjoint(child.op_arg1_);
+      op_arg2_.add_other_adjoint(child.op_arg2_);
+      op_arg3_.add_other_adjoint(child.op_arg3_);
+      op_arg4_.add_other_adjoint(child.op_arg4_);
     }
   };
 
@@ -350,13 +379,14 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
                const arg1_t& arg1, const arg2_t& arg2, const arg3_t& arg3,
                const arg4_t& arg4) const {
     const std::size_t num_jobs = vmapped.size();
-    vmapped_value_t vmapped_adjoint = adjoint_of(as_value(vmapped));
+
+    const vmapped_value_t vmapped_value = as_value(vmapped);
     const arg1_value_t arg1_value = as_value(arg1);
     const arg2_value_t arg2_value = as_value(arg2);
     const arg3_value_t arg3_value = as_value(arg3);
     const arg4_value_t arg4_value = as_value(arg4);
 
-    recursive_reducer worker(vmapped, vmapped_adjoint, init, arg1, arg1_value,
+    recursive_reducer worker(vmapped, vmapped_value, init, arg1, arg1_value,
                              arg2, arg2_value, arg3, arg3_value, arg4,
                              arg4_value);
 
@@ -372,16 +402,11 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
 
     std::vector<std::size_t> num_terms_arg(5, 0);
 
-    if (!is_constant<M>::value)
-      num_terms_arg[0] = num_elements(vmapped_adjoint);
-    if (!is_constant<Arg1>::value)
-      num_terms_arg[1] = num_elements(arg1_value);
-    if (!is_constant<Arg2>::value)
-      num_terms_arg[2] = num_elements(arg2_value);
-    if (!is_constant<Arg3>::value)
-      num_terms_arg[3] = num_elements(arg3_value);
-    if (!is_constant<Arg4>::value)
-      num_terms_arg[4] = num_elements(arg4_value);
+    num_terms_arg[0] = worker.op_vmapped_.num_elements();
+    num_terms_arg[1] = worker.op_arg1_.num_elements();
+    num_terms_arg[2] = worker.op_arg2_.num_elements();
+    num_terms_arg[3] = worker.op_arg3_.num_elements();
+    num_terms_arg[4] = worker.op_arg4_.num_elements();
 
     const std::size_t num_terms = sum(num_terms_arg);
 
@@ -392,32 +417,15 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
 
     std::size_t idx = 0;
 
-    if (!is_constant<vmapped_t>::value) {
-      register_operands(vmapped, &varis[idx]);
-      register_partials(vmapped_adjoint, &partials[idx]);
-      idx += num_terms_arg[0];
-    }
-
-    if (!is_constant<Arg1>::value) {
-      register_operands(arg1, &varis[idx]);
-      register_partials(worker.arg1_adjoint_, &partials[idx]);
-      idx += num_terms_arg[1];
-    }
-    if (!is_constant<Arg2>::value) {
-      register_operands(arg2, &varis[idx]);
-      register_partials(worker.arg2_adjoint_, &partials[idx]);
-      idx += num_terms_arg[2];
-    }
-    if (!is_constant<Arg3>::value) {
-      register_operands(arg3, &varis[idx]);
-      register_partials(worker.arg3_adjoint_, &partials[idx]);
-      idx += num_terms_arg[3];
-    }
-    if (!is_constant<Arg4>::value) {
-      register_operands(arg4, &varis[idx]);
-      register_partials(worker.arg4_adjoint_, &partials[idx]);
-      idx += num_terms_arg[4];
-    }
+    worker.op_vmapped_.build(&varis[idx], &partials[idx]);
+    idx += num_terms_arg[0];
+    worker.op_arg1_.build(&varis[idx], &partials[idx]);
+    idx += num_terms_arg[1];
+    worker.op_arg2_.build(&varis[idx], &partials[idx]);
+    idx += num_terms_arg[2];
+    worker.op_arg3_.build(&varis[idx], &partials[idx]);
+    idx += num_terms_arg[3];
+    worker.op_arg4_.build(&varis[idx], &partials[idx]);
 
     return var(new precomputed_gradients_vari(worker.terms_sum_, num_terms,
                                               varis, partials));

From f3b37aee69909c92885160a716f57b548a165650 Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Fri, 10 Jan 2020 19:55:22 +0100
Subject: [PATCH 025/189] start going back to better abstracted code

---
 stan/math/rev/functor/reduce_sum.hpp | 49 ++++++++++++++--------------
 1 file changed, 24 insertions(+), 25 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index a3a2530d813..4e5f03be8cb 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -2,7 +2,7 @@
 #define STAN_MATH_REV_SCAL_FUNCTOR_REDUCE_SUM_HPP
 
 #include <stan/math/prim/meta.hpp>
-#include <stan/math/rev/mat/fun/typedefs.hpp>
+#include <stan/math/rev/fun/typedefs.hpp>
 
 #include <tbb/task_arena.h>
 #include <tbb/parallel_reduce.h>
@@ -47,7 +47,7 @@ typename value_type<T>::type adjoint_of(const T x) {
   return typename value_type<T>::type(0);
 }
 
-double adjoint_of(const var& x) { return x.vi_->adj_; }
+inline double adjoint_of(const var& x) { return x.vi_->adj_; }
 
 template <typename T, int R, int C>
 inline Eigen::Matrix<typename value_type<T>::type, R, C> adjoint_of(
@@ -101,7 +101,7 @@ typename value_type<std::vector<T>>::type as_value(const std::vector<T>& x) {
   return result;
 }
 
-double as_value(const var& x) { return x.vi_->val_; }
+inline double as_value(const var& x) { return x.vi_->val_; }
 
 template <typename T, int R, int C>
 inline Eigen::Matrix<typename value_type<T>::type, R, C> as_value(
@@ -237,6 +237,15 @@ struct local_operand_and_partials {
     }
   }
 
+  /*
+  inline void add_local_adjoint() {
+    if (!is_constant<T>::value) {
+      add_adjoint(partials_, adjoint_of(local_op_), local_op_start_);
+      local_op_ = Op_t();
+    }
+  }
+  */
+
   inline void add_other_adjoint(const local_operand_and_partials<T>& other) {
     if (!is_constant<T>::value) {
       add_adjoint(partials_, other.partials_);
@@ -245,9 +254,9 @@ struct local_operand_and_partials {
 
   inline const Op_t local_op(std::size_t start = 0, std::size_t end = -1) {
     // local_op_start_ = start;
-    const Op_t local_op
-        = Op_t(op_value_.begin() + start,
-               (end == -1 ? op_value_.end() : op_value_.begin() + end));
+    const Op_t local_op(
+        op_value_.begin() + start,
+        (end == -1 ? op_value_.end() : op_value_.begin() + end));
     return std::move(local_op);
   }
 
@@ -287,7 +296,7 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
   using arg4_local_op_t = local_operand_and_partials<Arg4>;
 
   struct recursive_reducer {
-    vmapped_op_t op_vmapped_;
+    vmapped_op_t& op_vmapped_;
     arg1_local_op_t op_arg1_;
     arg2_local_op_t op_arg2_;
     arg3_local_op_t op_arg3_;
@@ -295,13 +304,12 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
 
     double terms_sum_;
 
-    recursive_reducer(const vmapped_t& vmapped,
-                      const vmapped_value_t& vmapped_value, const T& init,
+    recursive_reducer(vmapped_op_t& op_vmapped, const T& init,
                       const arg1_t& arg1, const arg1_value_t& arg1_value,
                       const arg2_t& arg2, const arg2_value_t& arg2_value,
                       const arg3_t& arg3, const arg3_value_t& arg3_value,
                       const arg4_t& arg4, const arg4_value_t& arg4_value)
-        : op_vmapped_(vmapped, vmapped_value),
+        : op_vmapped_(op_vmapped),
           op_arg1_(arg1, arg1_value),
           op_arg2_(arg2, arg2_value),
           op_arg3_(arg3, arg3_value),
@@ -328,7 +336,6 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
 
         const vmapped_t local_sub_slice
             = op_vmapped_.local_op(r.begin(), r.end());
-
         const arg1_t local_arg1 = op_arg1_.local_op();
         const arg2_t local_arg2 = op_arg2_.local_op();
         const arg3_t local_arg3 = op_arg3_.local_op();
@@ -338,15 +345,6 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
             = ReduceFunction()(r.begin(), r.end() - 1, local_sub_slice,
                                local_arg1, local_arg2, local_arg3, local_arg4);
 
-        /*
-        T sub_sum_v
-            = ReduceFunction()(r.begin(), r.end() - 1,
-                               op_vmapped_.local_op(r.begin(), r.end()),
-                               op_arg1_.local_op(),
-                               op_arg2_.local_op(),
-                               op_arg3_.local_op(),
-                               op_arg4_.local_op());
-        */
         sub_sum_v.grad();
 
         terms_sum_ += sub_sum_v.val();
@@ -386,9 +384,10 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
     const arg3_value_t arg3_value = as_value(arg3);
     const arg4_value_t arg4_value = as_value(arg4);
 
-    recursive_reducer worker(vmapped, vmapped_value, init, arg1, arg1_value,
-                             arg2, arg2_value, arg3, arg3_value, arg4,
-                             arg4_value);
+    vmapped_op_t op_vmapped(vmapped, vmapped_value);
+
+    recursive_reducer worker(op_vmapped, init, arg1, arg1_value, arg2,
+                             arg2_value, arg3, arg3_value, arg4, arg4_value);
 
 #ifdef STAN_DETERMINISTIC
     tbb::static_partitioner partitioner;
@@ -402,7 +401,7 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
 
     std::vector<std::size_t> num_terms_arg(5, 0);
 
-    num_terms_arg[0] = worker.op_vmapped_.num_elements();
+    num_terms_arg[0] = op_vmapped.num_elements();
     num_terms_arg[1] = worker.op_arg1_.num_elements();
     num_terms_arg[2] = worker.op_arg2_.num_elements();
     num_terms_arg[3] = worker.op_arg3_.num_elements();
@@ -417,7 +416,7 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
 
     std::size_t idx = 0;
 
-    worker.op_vmapped_.build(&varis[idx], &partials[idx]);
+    op_vmapped.build(&varis[idx], &partials[idx]);
     idx += num_terms_arg[0];
     worker.op_arg1_.build(&varis[idx], &partials[idx]);
     idx += num_terms_arg[1];

From 940fc8204256f19d23dcd64bbaa80f4ca9cf54e9 Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Sun, 12 Jan 2020 11:04:29 +0100
Subject: [PATCH 026/189] move to shared_ptr, simplify counstructor call

---
 stan/math/rev/functor/reduce_sum.hpp | 65 +++++++++++++++++++---------
 1 file changed, 44 insertions(+), 21 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 4e5f03be8cb..e49b9c7fac3 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -197,6 +197,27 @@ inline double* register_partials(const std::vector<T>& grad, double* partials) {
   return partials;
 }
 
+/*
+template <typename T_base>
+const T_base initialize_from_value(const typename value_type<T_base>::type&
+value) { const T_base base(value); return base;
+}
+*/
+
+template <typename T_base>
+const std::vector<T_base> initialize_from_value(
+    const std::vector<typename value_type<T_base>::type>& value) {
+  const std::vector<T_base> base(value.begin(), value.end());
+  return base;
+}
+
+/*
+template <typename T_base>
+const T_base initialize_from_value(const typename value_type<T_base>::type&
+value) { const T_base base(value.begin(), value.end()); return base;
+}
+*/
+
 template <typename T>
 struct local_operand_and_partials {
   using Op_t = std::vector<T>;
@@ -208,15 +229,17 @@ struct local_operand_and_partials {
   using partials_t = Op_value_t;
 
   const Op_t& op_;
+  // const Op_value_t& op_value_;
+  std::shared_ptr<const Op_value_t> op_value_ptr_;
   const Op_value_t& op_value_;
   // Op_t local_op_;
   // std::size_t local_op_start_;
   partials_t partials_;
 
-  explicit local_operand_and_partials(const Op_t& op,
-                                      const Op_value_t& op_value)
+  explicit local_operand_and_partials(const Op_t& op)
       : op_(op),
-        op_value_(op_value),
+        op_value_ptr_(new Op_value_t(as_value(op))),
+        op_value_(*op_value_ptr_),
         // local_op_(),
         // local_op_start_(0),
         partials_(is_constant<T>::value ? Op_value_t()
@@ -224,6 +247,7 @@ struct local_operand_and_partials {
 
   local_operand_and_partials(const local_operand_and_partials<T>& other)
       : op_(other.op_),
+        op_value_ptr_(other.op_value_ptr_),
         op_value_(other.op_value_),
         // local_op_(),
         // local_op_start_(0),
@@ -252,12 +276,18 @@ struct local_operand_and_partials {
     }
   }
 
-  inline const Op_t local_op(std::size_t start = 0, std::size_t end = -1) {
+  inline const Op_t local_op() { return initialize_from_value<T>(op_value_); }
+
+  inline const Op_t local_op(std::size_t start, std::size_t end) {
+    const Op_value_t slice(op_value_.begin() + start, op_value_.begin() + end);
+    return initialize_from_value<T>(slice);
+    /*
     // local_op_start_ = start;
     const Op_t local_op(
         op_value_.begin() + start,
         (end == -1 ? op_value_.end() : op_value_.begin() + end));
     return std::move(local_op);
+    */
   }
 
   inline std::size_t num_elements() {
@@ -283,11 +313,13 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
   using arg3_t = std::vector<Arg3>;
   using arg4_t = std::vector<Arg4>;
 
+  /*
   using vmapped_value_t = std::vector<typename value_type<M>::type>;
   using arg1_value_t = std::vector<typename value_type<Arg1>::type>;
   using arg2_value_t = std::vector<typename value_type<Arg2>::type>;
   using arg3_value_t = std::vector<typename value_type<Arg3>::type>;
   using arg4_value_t = std::vector<typename value_type<Arg4>::type>;
+  */
 
   using vmapped_op_t = local_operand_and_partials<M>;
   using arg1_local_op_t = local_operand_and_partials<Arg1>;
@@ -305,15 +337,13 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
     double terms_sum_;
 
     recursive_reducer(vmapped_op_t& op_vmapped, const T& init,
-                      const arg1_t& arg1, const arg1_value_t& arg1_value,
-                      const arg2_t& arg2, const arg2_value_t& arg2_value,
-                      const arg3_t& arg3, const arg3_value_t& arg3_value,
-                      const arg4_t& arg4, const arg4_value_t& arg4_value)
+                      const arg1_t& arg1, const arg2_t& arg2,
+                      const arg3_t& arg3, const arg4_t& arg4)
         : op_vmapped_(op_vmapped),
-          op_arg1_(arg1, arg1_value),
-          op_arg2_(arg2, arg2_value),
-          op_arg3_(arg3, arg3_value),
-          op_arg4_(arg4, arg4_value),
+          op_arg1_(arg1),
+          op_arg2_(arg2),
+          op_arg3_(arg3),
+          op_arg4_(arg4),
           terms_sum_(as_value(init)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
@@ -378,16 +408,9 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
                const arg4_t& arg4) const {
     const std::size_t num_jobs = vmapped.size();
 
-    const vmapped_value_t vmapped_value = as_value(vmapped);
-    const arg1_value_t arg1_value = as_value(arg1);
-    const arg2_value_t arg2_value = as_value(arg2);
-    const arg3_value_t arg3_value = as_value(arg3);
-    const arg4_value_t arg4_value = as_value(arg4);
-
-    vmapped_op_t op_vmapped(vmapped, vmapped_value);
+    vmapped_op_t op_vmapped(vmapped);
 
-    recursive_reducer worker(op_vmapped, init, arg1, arg1_value, arg2,
-                             arg2_value, arg3, arg3_value, arg4, arg4_value);
+    recursive_reducer worker(op_vmapped, init, arg1, arg2, arg3, arg4);
 
 #ifdef STAN_DETERMINISTIC
     tbb::static_partitioner partitioner;

From 8b66f94c7d6850efd180592a21897266a3ff3d2b Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Sun, 12 Jan 2020 12:10:13 +0100
Subject: [PATCH 027/189] move to partials being stored as flat vector

---
 stan/math/rev/functor/reduce_sum.hpp | 78 ++++++++++++++++++++++++----
 1 file changed, 68 insertions(+), 10 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index e49b9c7fac3..3f7092f6fde 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -129,6 +129,7 @@ inline const Eigen::Matrix<int, R, C>& as_value(
 
 namespace internal {
 
+/*
 template <typename T>
 inline void add_adjoint(T& sum, const T term) {
   sum += term;
@@ -148,6 +149,58 @@ inline void add_adjoint(std::vector<T>& sum, const std::vector<T>& term,
     add_adjoint(sum[offset + i], term[i]);
   }
 }
+*/
+
+inline int add_adjoint(const var& op, int offset_partials,
+                       Eigen::VectorXd& partials) {
+  partials(offset_partials) += op.vi_->adj_;
+  return ++offset_partials;
+}
+
+// template<typename Operand>
+inline int add_adjoint(const int op, int offset_partials,
+                       Eigen::VectorXd& partials) {
+  // no-op, does nothing
+  return offset_partials;
+}
+
+inline int add_adjoint(const double op, int offset_partials,
+                       Eigen::VectorXd& partials) {
+  // no-op, does nothing
+  return offset_partials;
+}
+
+template <int R, int C>
+inline int add_adjoint(const Eigen::Matrix<double, R, C>& op,
+                       int offset_partials, Eigen::VectorXd& partials) {
+  return offset_partials;
+}
+
+template <int R, int C>
+inline int add_adjoint(const Eigen::Matrix<int, R, C>& op, int offset_partials,
+                       Eigen::VectorXd& partials) {
+  return offset_partials;
+}
+
+template <int R, int C>
+inline int add_adjoint(const Eigen::Matrix<var, R, C>& op, int offset_partials,
+                       Eigen::VectorXd& partials) {
+  for (int j = 0; j != op.cols(); ++j) {
+    for (int i = 0; i != op.rows(); ++i, ++offset_partials) {
+      partials(offset_partials) += op(i, j).vi_->adj_;
+    }
+  }
+  return offset_partials;
+}
+
+template <typename Operand>
+inline int add_adjoint(const std::vector<Operand>& op, int offset_partials,
+                       Eigen::VectorXd& partials) {
+  for (size_t i = 0; i != op.size(); ++i) {
+    offset_partials = add_adjoint(op[i], offset_partials, partials);
+  }
+  return offset_partials;
+}
 
 inline vari** register_operands(const var& op, vari** varis) {
   (*varis) = op.vi_;
@@ -225,8 +278,8 @@ struct local_operand_and_partials {
   // will be either a const var to get local copies or a const value&
   // ref to avoid copying data... TODO
   using Op_local_t = Op_value_t;
-  // using partials_t = Eigen::VectorXd;
-  using partials_t = Op_value_t;
+  using partials_t = Eigen::VectorXd;
+  // using partials_t = Op_value_t;
 
   const Op_t& op_;
   // const Op_value_t& op_value_;
@@ -242,8 +295,10 @@ struct local_operand_and_partials {
         op_value_(*op_value_ptr_),
         // local_op_(),
         // local_op_start_(0),
-        partials_(is_constant<T>::value ? Op_value_t()
-                                        : adjoint_of(op_value_)) {}
+        partials_(Eigen::VectorXd::Zero(num_elements()))
+  // partials_(is_constant<T>::value ? Op_value_t()
+  //                                : adjoint_of(op_value_))
+  {}
 
   local_operand_and_partials(const local_operand_and_partials<T>& other)
       : op_(other.op_),
@@ -251,13 +306,14 @@ struct local_operand_and_partials {
         op_value_(other.op_value_),
         // local_op_(),
         // local_op_start_(0),
-        partials_(is_constant<T>::value ? Op_value_t()
-                                        : adjoint_of(other.op_value_)) {}
+        partials_(Eigen::VectorXd::Zero(num_elements()))
+  // partials_(is_constant<T>::value ? Op_value_t()
+  //                                : adjoint_of(other.op_value_))
+  {}
 
   inline void add_local_adjoint(const Op_t& local_op, std::size_t offset = 0) {
     if (!is_constant<T>::value) {
-      add_adjoint(partials_, adjoint_of(local_op), offset);
-      // local_op_ = Op_t();
+      add_adjoint(local_op, offset, partials_);
     }
   }
 
@@ -272,7 +328,8 @@ struct local_operand_and_partials {
 
   inline void add_other_adjoint(const local_operand_and_partials<T>& other) {
     if (!is_constant<T>::value) {
-      add_adjoint(partials_, other.partials_);
+      // add_adjoint(partials_, other.partials_);
+      partials_ += other.partials_;
     }
   }
 
@@ -299,7 +356,8 @@ struct local_operand_and_partials {
   inline void build(vari** varis, double* partials) {
     if (!is_constant<T>::value) {
       register_operands(op_, varis);
-      register_partials(partials_, partials);
+      std::copy(partials_.data(), partials_.data() + partials_.size(),
+                partials);
     }
   }
 };

From e56cdf287d02bd48b2a4cc1827053447388fb31d Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Sun, 12 Jan 2020 12:16:49 +0100
Subject: [PATCH 028/189] get rid of obsolete code

---
 stan/math/rev/functor/reduce_sum.hpp | 136 +--------------------------
 1 file changed, 2 insertions(+), 134 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 3f7092f6fde..cba68245b21 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -40,48 +40,6 @@ struct value_type<Eigen::Matrix<T_value, R, C>> {
   using type = Eigen::Matrix<typename value_type<T_value>::type, R, C>;
 };
 
-// adjoint_of grabs the adjoint of some data structure
-
-template <typename T>
-typename value_type<T>::type adjoint_of(const T x) {
-  return typename value_type<T>::type(0);
-}
-
-inline double adjoint_of(const var& x) { return x.vi_->adj_; }
-
-template <typename T, int R, int C>
-inline Eigen::Matrix<typename value_type<T>::type, R, C> adjoint_of(
-    const Eigen::Matrix<T, R, C>& M) {
-  Eigen::Matrix<typename value_type<T>::type, R, C> Md(M.rows(), M.cols());
-  for (int j = 0; j < M.cols(); j++) {
-    for (int i = 0; i < M.rows(); i++) {
-      Md(i, j) = adjoint_of(M(i, j));
-    }
-  }
-  return Md;
-}
-
-template <int R, int C>
-inline Eigen::Matrix<double, R, C> adjoint_of(
-    const Eigen::Matrix<double, R, C>& x) {
-  return Eigen::Matrix<double, R, C>::Zero(x.rows(), x.cols());
-}
-
-template <int R, int C>
-inline Eigen::Matrix<int, R, C> adjoint_of(const Eigen::Matrix<int, R, C>& x) {
-  return Eigen::Matrix<int, R, C>::Zero(x.rows(), x.cols());
-}
-
-template <typename T>
-typename value_type<std::vector<T>>::type adjoint_of(const std::vector<T>& x) {
-  const size_t size = x.size();
-  typename value_type<std::vector<T>>::type result(size);
-  for (size_t i = 0; i != size; ++i) {
-    result[i] = adjoint_of(x[i]);
-  }
-  return result;
-}
-
 // as_value is similar to value_of... with the difference that it
 // keeps nested container structures which is not the case for
 // value_of
@@ -129,28 +87,6 @@ inline const Eigen::Matrix<int, R, C>& as_value(
 
 namespace internal {
 
-/*
-template <typename T>
-inline void add_adjoint(T& sum, const T term) {
-  sum += term;
-}
-
-template <typename T, int R, int C>
-inline void add_adjoint(Eigen::Matrix<T, R, C>& sum,
-                        const Eigen::Matrix<T, R, C>& term) {
-  sum += term;
-}
-
-template <typename T>
-inline void add_adjoint(std::vector<T>& sum, const std::vector<T>& term,
-                        int offset = 0) {
-  const size_t size = term.size();
-  for (size_t i = 0; i != size; ++i) {
-    add_adjoint(sum[offset + i], term[i]);
-  }
-}
-*/
-
 inline int add_adjoint(const var& op, int offset_partials,
                        Eigen::VectorXd& partials) {
   partials(offset_partials) += op.vi_->adj_;
@@ -228,35 +164,6 @@ inline vari** register_operands(const std::vector<T>& op, vari** varis) {
   return varis;
 }
 
-inline double* register_partials(const double grad, double* partials) {
-  (*partials) = grad;
-  return partials + 1;
-}
-
-template <int R, int C>
-inline double* register_partials(const Eigen::Matrix<double, R, C>& M_grad,
-                                 double* partials) {
-  const size_t size = M_grad.size();
-  std::copy(M_grad.data(), M_grad.data() + size, partials);
-  return partials + size;
-}
-
-template <typename T>
-inline double* register_partials(const std::vector<T>& grad, double* partials) {
-  const size_t size = grad.size();
-  for (size_t i = 0; i != size; ++i) {
-    partials = register_partials(grad[i], partials);
-  }
-  return partials;
-}
-
-/*
-template <typename T_base>
-const T_base initialize_from_value(const typename value_type<T_base>::type&
-value) { const T_base base(value); return base;
-}
-*/
-
 template <typename T_base>
 const std::vector<T_base> initialize_from_value(
     const std::vector<typename value_type<T_base>::type>& value) {
@@ -279,37 +186,23 @@ struct local_operand_and_partials {
   // ref to avoid copying data... TODO
   using Op_local_t = Op_value_t;
   using partials_t = Eigen::VectorXd;
-  // using partials_t = Op_value_t;
 
   const Op_t& op_;
-  // const Op_value_t& op_value_;
   std::shared_ptr<const Op_value_t> op_value_ptr_;
   const Op_value_t& op_value_;
-  // Op_t local_op_;
-  // std::size_t local_op_start_;
   partials_t partials_;
 
   explicit local_operand_and_partials(const Op_t& op)
       : op_(op),
         op_value_ptr_(new Op_value_t(as_value(op))),
         op_value_(*op_value_ptr_),
-        // local_op_(),
-        // local_op_start_(0),
-        partials_(Eigen::VectorXd::Zero(num_elements()))
-  // partials_(is_constant<T>::value ? Op_value_t()
-  //                                : adjoint_of(op_value_))
-  {}
+        partials_(Eigen::VectorXd::Zero(num_elements())) {}
 
   local_operand_and_partials(const local_operand_and_partials<T>& other)
       : op_(other.op_),
         op_value_ptr_(other.op_value_ptr_),
         op_value_(other.op_value_),
-        // local_op_(),
-        // local_op_start_(0),
-        partials_(Eigen::VectorXd::Zero(num_elements()))
-  // partials_(is_constant<T>::value ? Op_value_t()
-  //                                : adjoint_of(other.op_value_))
-  {}
+        partials_(Eigen::VectorXd::Zero(num_elements())) {}
 
   inline void add_local_adjoint(const Op_t& local_op, std::size_t offset = 0) {
     if (!is_constant<T>::value) {
@@ -317,18 +210,8 @@ struct local_operand_and_partials {
     }
   }
 
-  /*
-  inline void add_local_adjoint() {
-    if (!is_constant<T>::value) {
-      add_adjoint(partials_, adjoint_of(local_op_), local_op_start_);
-      local_op_ = Op_t();
-    }
-  }
-  */
-
   inline void add_other_adjoint(const local_operand_and_partials<T>& other) {
     if (!is_constant<T>::value) {
-      // add_adjoint(partials_, other.partials_);
       partials_ += other.partials_;
     }
   }
@@ -338,13 +221,6 @@ struct local_operand_and_partials {
   inline const Op_t local_op(std::size_t start, std::size_t end) {
     const Op_value_t slice(op_value_.begin() + start, op_value_.begin() + end);
     return initialize_from_value<T>(slice);
-    /*
-    // local_op_start_ = start;
-    const Op_t local_op(
-        op_value_.begin() + start,
-        (end == -1 ? op_value_.end() : op_value_.begin() + end));
-    return std::move(local_op);
-    */
   }
 
   inline std::size_t num_elements() {
@@ -371,14 +247,6 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
   using arg3_t = std::vector<Arg3>;
   using arg4_t = std::vector<Arg4>;
 
-  /*
-  using vmapped_value_t = std::vector<typename value_type<M>::type>;
-  using arg1_value_t = std::vector<typename value_type<Arg1>::type>;
-  using arg2_value_t = std::vector<typename value_type<Arg2>::type>;
-  using arg3_value_t = std::vector<typename value_type<Arg3>::type>;
-  using arg4_value_t = std::vector<typename value_type<Arg4>::type>;
-  */
-
   using vmapped_op_t = local_operand_and_partials<M>;
   using arg1_local_op_t = local_operand_and_partials<Arg1>;
   using arg2_local_op_t = local_operand_and_partials<Arg2>;

From 2cece58b1757b4505065c960fe5f3a08b6ca08b5 Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Sun, 12 Jan 2020 12:44:47 +0100
Subject: [PATCH 029/189] add preliminary support for structured slicing
 arguments which are not just scalars

---
 stan/math/rev/functor/reduce_sum.hpp          |  27 ++++-
 .../functor/parallel_v3_reduce_sum_test.cpp   | 105 ++++++++++++++++++
 2 files changed, 128 insertions(+), 4 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index cba68245b21..d12c108d372 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -164,6 +164,15 @@ inline vari** register_operands(const std::vector<T>& op, vari** varis) {
   return varis;
 }
 
+/* this template is not picked up when it should??
+template <typename T_base>
+const std::vector< std::vector<T_base>> initialize_from_value(
+    const std::vector<std::vector<typename value_type<T_base>::type>>& value) {
+  std::vector<std::vector<T_base>> base(value.size(),
+std::vector<T_base>(value.size(), 0)); return base;
+}
+*/
+
 template <typename T_base>
 const std::vector<T_base> initialize_from_value(
     const std::vector<typename value_type<T_base>::type>& value) {
@@ -260,16 +269,19 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
     arg3_local_op_t op_arg3_;
     arg4_local_op_t op_arg4_;
 
+    const std::size_t num_vmapped_adjoints_per_element_;
     double terms_sum_;
 
-    recursive_reducer(vmapped_op_t& op_vmapped, const T& init,
-                      const arg1_t& arg1, const arg2_t& arg2,
+    recursive_reducer(vmapped_op_t& op_vmapped,
+                      std::size_t num_vmapped_adjoints_per_element,
+                      const T& init, const arg1_t& arg1, const arg2_t& arg2,
                       const arg3_t& arg3, const arg4_t& arg4)
         : op_vmapped_(op_vmapped),
           op_arg1_(arg1),
           op_arg2_(arg2),
           op_arg3_(arg3),
           op_arg4_(arg4),
+          num_vmapped_adjoints_per_element_(num_vmapped_adjoints_per_element),
           terms_sum_(as_value(init)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
@@ -278,6 +290,8 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
           op_arg2_(other.op_arg2_),
           op_arg3_(other.op_arg3_),
           op_arg4_(other.op_arg4_),
+          num_vmapped_adjoints_per_element_(
+              other.num_vmapped_adjoints_per_element_),
           terms_sum_(0.0) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
@@ -305,7 +319,8 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
 
         terms_sum_ += sub_sum_v.val();
 
-        op_vmapped_.add_local_adjoint(local_sub_slice, r.begin());
+        op_vmapped_.add_local_adjoint(
+            local_sub_slice, num_vmapped_adjoints_per_element_ * r.begin());
 
         op_arg1_.add_local_adjoint(local_arg1);
         op_arg2_.add_local_adjoint(local_arg2);
@@ -334,9 +349,13 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
                const arg4_t& arg4) const {
     const std::size_t num_jobs = vmapped.size();
 
+    if (num_jobs == 0)
+      return init;
+
     vmapped_op_t op_vmapped(vmapped);
 
-    recursive_reducer worker(op_vmapped, init, arg1, arg2, arg3, arg4);
+    recursive_reducer worker(op_vmapped, num_elements(vmapped[0]), init, arg1,
+                             arg2, arg3, arg4);
 
 #ifdef STAN_DETERMINISTIC
     tbb::static_partitioner partitioner;
diff --git a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
index f12c87651b9..470798fda62 100644
--- a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
@@ -371,3 +371,108 @@ TEST(v3_reduce_sum, slice_group_gradient) {
   ;
   stan::math::recover_memory();
 }
+
+// ********************************
+// slice over the grouping variable which is a var and the slicing
+// variable itself has more structure than just being a vector of vars.
+// ********************************
+
+template <typename T>
+struct slice_groupNested_count_lpdf {
+  slice_groupNested_count_lpdf() {}
+
+  // does the reduction in the sub-slice start to end
+  inline T operator()(std::size_t start, std::size_t end,
+                      const std::vector<std::vector<T>>& lambda_slice,
+                      const std::vector<int>& y,
+                      const std::vector<int>& gsidx) const {
+    const std::size_t num_groups = end - start + 1;
+    T result = 0.0;
+    for (std::size_t i = 0; i != num_groups; ++i) {
+      std::vector<int> y_group(y.begin() + gsidx[start + i],
+                               y.begin() + gsidx[start + i + 1]);
+      result += stan::math::poisson_lpmf(
+          y_group, lambda_slice[i][0] + lambda_slice[i][1]);
+    }
+    return result;
+  }
+};
+
+/* this should be supported if possible. it requires to allow
+ * initialization from nested structures and it requires that the
+ * offset handling is correct in the slicing code which right now
+ * assumes that each array element which we slice only has a single adjoint.
+ */
+/*
+TEST(v3_reduce_sum, slice_groupNested_gradient) {
+  stan::math::init_threadpool_tbb();
+
+  double lambda_d = 10.0;
+  const std::size_t groups = 10;
+  const std::size_t elems_per_group = 1000;
+  const std::size_t elems = groups * elems_per_group;
+  const std::size_t num_iter = 1000;
+
+  std::vector<int> data(elems);
+  std::vector<int> gidx(elems);
+  std::vector<int> gsidx(groups + 1);
+
+  for (std::size_t i = 0, k = 0; i != groups; ++i) {
+    gsidx[i] = k;
+    for (std::size_t j = 0; j != elems_per_group; ++j, ++k) {
+      data[k] = k;
+      gidx[k] = i;
+    }
+    gsidx[i + 1] = k;
+  }
+
+  using stan::math::var;
+
+  std::vector<std::vector<var>> vlambda_v;
+
+  for (std::size_t i = 0; i != groups; ++i) {
+    var l1 = i + 0.2;
+    var l2 = 2*i + 0.2;
+    std::vector<var> terms;
+    terms.push_back(l1);
+    terms.push_back(l2);
+    vlambda_v.push_back(terms);
+  }
+
+  var lambda_v = vlambda_v[0][0];
+
+  var poisson_lpdf = stan::math::reduce_sum<slice_groupNested_count_lpdf<var>>(
+      vlambda_v, var(0.0), 5, data, gsidx);
+
+  std::vector<var> vref_lambda_v;
+  for (std::size_t i = 0; i != elems; ++i) {
+    vref_lambda_v.push_back(vlambda_v[gidx[i]][0] + vlambda_v[gidx[i]][1]);
+  }
+  var lambda_ref = vlambda_v[0];
+
+  var poisson_lpdf_ref = stan::math::poisson_lpmf(data, vref_lambda_v);
+
+  EXPECT_FLOAT_EQ(value_of(poisson_lpdf), value_of(poisson_lpdf_ref));
+
+  stan::math::grad(poisson_lpdf_ref.vi_);
+  const double lambda_ref_adj = lambda_ref.adj();
+
+  stan::math::set_zero_all_adjoints();
+  stan::math::grad(poisson_lpdf.vi_);
+  const double lambda_adj = lambda_v.adj();
+
+  EXPECT_FLOAT_EQ(lambda_adj, lambda_ref_adj);
+
+  std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref.val()
+            << std::endl;
+  ;
+  std::cout << "ref gradient wrt to lambda: " << lambda_ref_adj << std::endl;
+  ;
+
+  std::cout << "value of poisson lpdf : " << poisson_lpdf.val() << std::endl;
+  ;
+  std::cout << "gradient wrt to lambda: " << lambda_adj << std::endl;
+  ;
+  stan::math::recover_memory();
+}
+*/

From 71c0196b8e5be03091c7ee2a248ef86434fc6c81 Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Sun, 12 Jan 2020 18:21:52 +0100
Subject: [PATCH 030/189] add special case of local_operands_and_partials for
 non-var in a workaround way

---
 stan/math/rev/functor/reduce_sum.hpp | 110 ++++++++++++++++++++++++---
 1 file changed, 98 insertions(+), 12 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index d12c108d372..df5b3555319 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -173,6 +173,8 @@ std::vector<T_base>(value.size(), 0)); return base;
 }
 */
 
+// use enable_if style to allow constuction of scalars and Eigen
+// things as well.
 template <typename T_base>
 const std::vector<T_base> initialize_from_value(
     const std::vector<typename value_type<T_base>::type>& value) {
@@ -187,13 +189,19 @@ value) { const T_base base(value.begin(), value.end()); return base;
 }
 */
 
+/*
+ * we should apply some meta magic to defined
+ * local_operands_and_partials based on wether is_constant<T> is true
+ * or false (instead of having this as if in every function). As a
+ * work-around I have below partial template specializations which
+ * give me the same effect with much less generality.
+ */
 template <typename T>
 struct local_operand_and_partials {
   using Op_t = std::vector<T>;
   using Op_value_t = std::vector<typename value_type<T>::type>;
-  // will be either a const var to get local copies or a const value&
-  // ref to avoid copying data... TODO
-  using Op_local_t = Op_value_t;
+  using Op_local_t = Op_t;
+  using Op_local_slice_t = Op_t;
   using partials_t = Eigen::VectorXd;
 
   const Op_t& op_;
@@ -225,20 +233,23 @@ struct local_operand_and_partials {
     }
   }
 
-  inline const Op_t local_op() { return initialize_from_value<T>(op_value_); }
+  inline const Op_local_t local_op() const {
+    return initialize_from_value<T>(op_value_);
+  }
 
-  inline const Op_t local_op(std::size_t start, std::size_t end) {
+  inline const Op_local_slice_t local_op(std::size_t start,
+                                         std::size_t end) const {
     const Op_value_t slice(op_value_.begin() + start, op_value_.begin() + end);
     return initialize_from_value<T>(slice);
   }
 
-  inline std::size_t num_elements() {
+  inline std::size_t num_elements() const {
     if (!is_constant<T>::value)
       return stan::math::num_elements(op_value_);
     return 0;
   }
 
-  inline void build(vari** varis, double* partials) {
+  inline void build(vari** varis, double* partials) const {
     if (!is_constant<T>::value) {
       register_operands(op_, varis);
       std::copy(partials_.data(), partials_.data() + partials_.size(),
@@ -247,6 +258,77 @@ struct local_operand_and_partials {
   }
 };
 
+/* for types which are constants (non-vars), the implemtation can be
+ * seriously simplified and based on constant refs being returned
+ */
+
+template <>
+struct local_operand_and_partials<double> {
+  using Op_t = std::vector<double>;
+  using Op_local_t = const Op_t&;
+  using Op_local_slice_t = Op_t;
+
+  const Op_t& op_;
+
+  explicit local_operand_and_partials(const Op_t& op) : op_(op) {}
+
+  local_operand_and_partials(const local_operand_and_partials<double>& other)
+      : op_(other.op_) {}
+
+  inline void add_local_adjoint(const Op_t& local_op, std::size_t offset = 0) {}
+
+  inline void add_other_adjoint(
+      const local_operand_and_partials<double>& other) {}
+
+  inline Op_local_t local_op() const { return op_; }
+
+  inline const Op_local_slice_t local_op(std::size_t start,
+                                         std::size_t end) const {
+    const Op_local_slice_t slice(op_.begin() + start, op_.begin() + end);
+    return slice;
+  }
+
+  inline std::size_t num_elements() const { return 0; }
+
+  inline void build(vari** varis, double* partials) const {}
+};
+
+template <>
+struct local_operand_and_partials<int> {
+  using Op_t = std::vector<int>;
+  using Op_local_t = const Op_t&;
+  using Op_local_slice_t = Op_t;
+
+  const Op_t& op_;
+
+  explicit local_operand_and_partials(const Op_t& op) : op_(op) {}
+
+  local_operand_and_partials(const local_operand_and_partials<int>& other)
+      : op_(other.op_) {}
+
+  inline void add_local_adjoint(const Op_t& local_op, std::size_t offset = 0) {}
+
+  inline void add_other_adjoint(const local_operand_and_partials<int>& other) {}
+
+  inline Op_local_t local_op() const { return op_; }
+
+  inline const Op_local_slice_t local_op(std::size_t start,
+                                         std::size_t end) const {
+    const Op_local_slice_t slice(op_.begin() + start, op_.begin() + end);
+    return slice;
+  }
+
+  inline std::size_t num_elements() const { return 0; }
+
+  inline void build(vari** varis, double* partials) const {}
+};
+
+/*
+template <typename T, typename = void>
+struct local_operand_and_partials<T, > {
+};
+*/
+
 template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
           class Arg3, class Arg4>
 struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
@@ -304,12 +386,16 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
         // create a deep copy of all var's so that these are not
         // linked to any outer AD tree
 
-        const vmapped_t local_sub_slice
+        const typename vmapped_op_t::Op_local_slice_t local_sub_slice
             = op_vmapped_.local_op(r.begin(), r.end());
-        const arg1_t local_arg1 = op_arg1_.local_op();
-        const arg2_t local_arg2 = op_arg2_.local_op();
-        const arg3_t local_arg3 = op_arg3_.local_op();
-        const arg4_t local_arg4 = op_arg4_.local_op();
+        const typename arg1_local_op_t::Op_local_t local_arg1
+            = op_arg1_.local_op();
+        const typename arg2_local_op_t::Op_local_t local_arg2
+            = op_arg2_.local_op();
+        const typename arg3_local_op_t::Op_local_t local_arg3
+            = op_arg3_.local_op();
+        const typename arg4_local_op_t::Op_local_t local_arg4
+            = op_arg4_.local_op();
 
         T sub_sum_v
             = ReduceFunction()(r.begin(), r.end() - 1, local_sub_slice,

From e2b20d709a7267d06d4910a9b7aac8eb2fae7811 Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Tue, 14 Jan 2020 01:42:08 -0500
Subject: [PATCH 031/189] start cleanup bits of the reduce_sum code. Mostly to
 get an idea of what I want it to look like

---
 stan/math/prim/scal/functor/reduce_sum.hpp | 194 ++++-----------------
 1 file changed, 30 insertions(+), 164 deletions(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index e1ac9e6c625..bda2fb759ec 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -19,49 +19,40 @@ namespace math {
 
 namespace internal {
 
+
 // base definition => compile error
-template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
-          class Arg3, class Arg4, class T_return_type>
+template <typename ReduceFunction, typename Enable = void, typename M, typename T, typename... Args>
 struct reduce_sum_impl {};
 
-template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
-          class Arg3, class Arg4>
-struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, double> {
+// todo, double check if I need enable if here
+template <typename ReduceFunction, typename M, typename T, typename... Args>
+struct reduce_sum_impl<ReduceFunction, M, T, double, Args...> {
   using vmapped_t = std::vector<M>;
   using arg1_t = std::vector<Arg1>;
   using arg2_t = std::vector<Arg2>;
   using arg3_t = std::vector<Arg3>;
   using arg4_t = std::vector<Arg4>;
-
-  struct recursive_reducer {
-    const vmapped_t& vmapped_;
-    const arg1_t& arg1_;
-    const arg2_t& arg2_;
-    const arg3_t& arg3_;
-    const arg4_t& arg4_;
-    T terms_sum_;
-
-    recursive_reducer(const vmapped_t& vmapped, const T& init,
-                      const arg1_t& arg1, const arg2_t& arg2,
-                      const arg3_t& arg3, const arg4_t& arg4)
+  std::tuple<std::vector<Args>...> arg_;
+  const vmapped_t& vmapped_;
+  const arg1_t& arg1_;
+  const arg2_t& arg2_;
+  const arg3_t& arg3_;
+  const arg4_t& arg4_;
+  T terms_sum_;
+    reduce_sum_impl(const vmapped_t& vmapped, const T& init, Args&&... args)
         : vmapped_(vmapped),
-          arg1_(arg1),
-          arg2_(arg2),
-          arg3_(arg3),
-          arg4_(arg4),
+          arg_(std::make_tuple(std::forward<Args>(args)...))
           terms_sum_(value_of(init)) {}
 
-    recursive_reducer(recursive_reducer& other, tbb::split)
+    reduce_sum_impl(reduce_sum_impl& other, tbb::split)
         : vmapped_(other.vmapped_),
-          arg1_(other.arg1_),
-          arg2_(other.arg2_),
-          arg3_(other.arg3_),
-          arg4_(other.arg4_),
-          terms_sum_(0.0) {}
+        arg_(other.arg_),
+        terms_sum_(0.0) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
-      if (r.empty())
+      if (r.empty()) {
         return;
+      }
 
       auto start = vmapped_.begin();
       std::advance(start, r.begin());
@@ -74,99 +65,22 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, double> {
                                      arg2_, arg3_, arg4_);
     }
 
-    void join(const recursive_reducer& child) {
+    void join(const reduce_sum_impl& child) {
       terms_sum_ += child.terms_sum_;
     }
-  };
 
+  // Todo: Better name for this than operator(), collect()?
+  template <typename... OtherArgs>
   T operator()(const vmapped_t& vmapped, T init, std::size_t grainsize,
-               const arg1_t& arg1, const arg2_t& arg2, const arg3_t& arg3,
-               const arg4_t& arg4) const {
+               Args&&... args) const {
     const std::size_t num_jobs = vmapped.size();
-    recursive_reducer worker(vmapped, init, arg1, arg2, arg3, arg4);
+    reduce_sum_impl<ReduceFunction, M, T, OtherArgs...> worker(vmapped, init, args...);
     tbb::parallel_reduce(
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
     return std::move(worker.terms_sum_);
   }
 };
 
-/* The reduce_function_arg_adapter adapts the user functor to
- * conventions used in the reduce_sum functions. While the user
- * functor is allowed to specify optionally up to 4 additional
- * arguments, the reduce_sum functions always expect 4
- * arguments. Thus, the call of the reduce_sum functions with 4
- * arguments get adapted to the user functors by dropping the
- * arguments which are not used.
- */
-// default gives a compile time error
-template <class ReduceFunction, int optional_args>
-struct reduce_function_arg_adapter {};
-
-template <class ReduceFunction>
-struct reduce_function_arg_adapter<ReduceFunction, 4> {
-  template <class M, class Arg1, class Arg2, class Arg3, class Arg4>
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<M>& vmapped_slice,
-                         const std::vector<Arg1>& arg1,
-                         const std::vector<Arg2>& arg2,
-                         const std::vector<Arg3>& arg3,
-                         const std::vector<Arg4>& arg4) const {
-    return ReduceFunction()(start, end, vmapped_slice, arg1, arg2, arg3, arg4);
-  }
-};
-
-template <class ReduceFunction>
-struct reduce_function_arg_adapter<ReduceFunction, 3> {
-  template <class M, class Arg1, class Arg2, class Arg3, class Arg4>
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<M>& vmapped_slice,
-                         const std::vector<Arg1>& arg1,
-                         const std::vector<Arg2>& arg2,
-                         const std::vector<Arg3>& arg3,
-                         const std::vector<Arg4>& arg4) const {
-    return ReduceFunction()(start, end, vmapped_slice, arg1, arg2, arg3);
-  }
-};
-
-template <class ReduceFunction>
-struct reduce_function_arg_adapter<ReduceFunction, 2> {
-  template <class M, class Arg1, class Arg2, class Arg3, class Arg4>
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<M>& vmapped_slice,
-                         const std::vector<Arg1>& arg1,
-                         const std::vector<Arg2>& arg2,
-                         const std::vector<Arg3>& arg3,
-                         const std::vector<Arg4>& arg4) const {
-    return ReduceFunction()(start, end, vmapped_slice, arg1, arg2);
-  }
-};
-
-template <class ReduceFunction>
-struct reduce_function_arg_adapter<ReduceFunction, 1> {
-  template <class M, class Arg1, class Arg2, class Arg3, class Arg4>
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<M>& vmapped_slice,
-                         const std::vector<Arg1>& arg1,
-                         const std::vector<Arg2>& arg2,
-                         const std::vector<Arg3>& arg3,
-                         const std::vector<Arg4>& arg4) const {
-    return ReduceFunction()(start, end, vmapped_slice, arg1);
-  }
-};
-
-template <class ReduceFunction>
-struct reduce_function_arg_adapter<ReduceFunction, 0> {
-  template <class M, class Arg1, class Arg2, class Arg3, class Arg4>
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<M>& vmapped_slice,
-                         const std::vector<Arg1>& arg1,
-                         const std::vector<Arg2>& arg2,
-                         const std::vector<Arg3>& arg3,
-                         const std::vector<Arg4>& arg4) const {
-    return ReduceFunction()(start, end, vmapped_slice);
-  }
-};
-
 }  // namespace internal
 
 /*
@@ -174,64 +88,16 @@ struct reduce_function_arg_adapter<ReduceFunction, 0> {
  * that any internal state of the functor is causing trouble. Thus,
  * the functor must be default constructible without any arguments.
  */
-template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
-          class Arg3, class Arg4>
-constexpr T reduce_sum(const std::vector<M>& vmapped, T init,
-                       std::size_t grainsize, const std::vector<Arg1>& arg1,
-                       const std::vector<Arg2>& arg2,
-                       const std::vector<Arg3>& arg3,
-                       const std::vector<Arg4>& arg4) {
-  typedef T return_base_t;
-  return internal::reduce_sum_impl<
-      internal::reduce_function_arg_adapter<ReduceFunction, 4>, M, T, Arg1,
-      Arg2, Arg3, Arg4, return_base_t>()(vmapped, init, grainsize, arg1, arg2,
-                                         arg3, arg4);
-}
-
-template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
-          class Arg3>
-constexpr T reduce_sum(const std::vector<M>& vmapped, T init,
-                       std::size_t grainsize, const std::vector<Arg1>& arg1,
-                       const std::vector<Arg2>& arg2,
-                       const std::vector<Arg3>& arg3) {
-  typedef T return_base_t;
-  return internal::reduce_sum_impl<
-      internal::reduce_function_arg_adapter<ReduceFunction, 3>, M, T, Arg1,
-      Arg2, Arg3, int, return_base_t>()(vmapped, init, grainsize, arg1, arg2,
-                                        arg3, std::vector<int>());
-}
-
-template <class ReduceFunction, class M, class T, class Arg1, class Arg2>
-constexpr T reduce_sum(const std::vector<M>& vmapped, T init,
-                       std::size_t grainsize, const std::vector<Arg1>& arg1,
-                       const std::vector<Arg2>& arg2) {
-  typedef T return_base_t;
-  return internal::reduce_sum_impl<
-      internal::reduce_function_arg_adapter<ReduceFunction, 2>, M, T, Arg1,
-      Arg2, int, int, return_base_t>()(vmapped, init, grainsize, arg1, arg2,
-                                       std::vector<int>(), std::vector<int>());
-}
-template <class ReduceFunction, class M, class T, class Arg1>
+template <typename ReduceFunction, typename M, typename T, typename... Args>
 constexpr T reduce_sum(const std::vector<M>& vmapped, T init,
-                       std::size_t grainsize, const std::vector<Arg1>& arg1) {
+                       std::size_t grainsize, Args&&... args) {
   typedef T return_base_t;
-  return internal::reduce_sum_impl<
-      internal::reduce_function_arg_adapter<ReduceFunction, 1>, M, T, Arg1, int,
-      int, int, return_base_t>()(vmapped, init, grainsize, arg1,
-                                 std::vector<int>(), std::vector<int>(),
-                                 std::vector<int>());
+  // void here but need to figure out enable_if stuff
+  // We do this somewhere in the opencl code
+  return internal::reduce_sum_impl<ReduceFunction, M, T, void, Args...>()(
+    vmapped, init, grainsize, std::forward<Args>(args)...);
 }
 
-template <class ReduceFunction, class M, class T>
-constexpr T reduce_sum(const std::vector<M>& vmapped, T init,
-                       std::size_t grainsize) {
-  typedef T return_base_t;
-  return internal::reduce_sum_impl<
-      internal::reduce_function_arg_adapter<ReduceFunction, 0>, M, T, int, int,
-      int, int, return_base_t>()(vmapped, init, grainsize, std::vector<int>(),
-                                 std::vector<int>(), std::vector<int>(),
-                                 std::vector<int>());
-}
 
 }  // namespace math
 }  // namespace stan

From c0c118a8ca5542df8625f6956b50568745e5755e Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Tue, 14 Jan 2020 01:45:47 -0500
Subject: [PATCH 032/189] start cleanup bits of the reduce_sum code. Mostly to
 get an idea of what I want it to look like

---
 stan/math/prim/scal/functor/reduce_sum.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index bda2fb759ec..75b65d485da 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -39,6 +39,8 @@ struct reduce_sum_impl<ReduceFunction, M, T, double, Args...> {
   const arg3_t& arg3_;
   const arg4_t& arg4_;
   T terms_sum_;
+
+  // todo(Steve): put back recursive reducer
     reduce_sum_impl(const vmapped_t& vmapped, const T& init, Args&&... args)
         : vmapped_(vmapped),
           arg_(std::make_tuple(std::forward<Args>(args)...))

From ff0f582eafea2e70c91baf0253700d243d9c4d24 Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Tue, 14 Jan 2020 01:49:25 -0500
Subject: [PATCH 033/189] start cleanup bits of the reduce_sum code. Mostly to
 get an idea of what I want it to look like

---
 stan/math/prim/scal/functor/reduce_sum.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index 75b65d485da..95d4e353fc4 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -26,12 +26,13 @@ struct reduce_sum_impl {};
 
 // todo, double check if I need enable if here
 template <typename ReduceFunction, typename M, typename T, typename... Args>
-struct reduce_sum_impl<ReduceFunction, M, T, double, Args...> {
+struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<T>, M, T, Args...> {
   using vmapped_t = std::vector<M>;
   using arg1_t = std::vector<Arg1>;
   using arg2_t = std::vector<Arg2>;
   using arg3_t = std::vector<Arg3>;
   using arg4_t = std::vector<Arg4>;
+  // todo(Steve): Need helper funcs for manipulating / iterating tuples
   std::tuple<std::vector<Args>...> arg_;
   const vmapped_t& vmapped_;
   const arg1_t& arg1_;

From 96e8c8ee6a06870af61c73540a9772084a5d8d4f Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Tue, 14 Jan 2020 01:51:49 -0500
Subject: [PATCH 034/189] start cleanup bits of the reduce_sum code. Mostly to
 get an idea of what I want it to look like

---
 stan/math/prim/scal/functor/reduce_sum.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index 95d4e353fc4..0f61247784e 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -64,8 +64,7 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<T>, M, T, Args...> {
 
       const vmapped_t sub_slice(start, end);
 
-      terms_sum_ += ReduceFunction()(r.begin(), r.end() - 1, sub_slice, arg1_,
-                                     arg2_, arg3_, arg4_);
+      terms_sum_ += ReduceFunction()(r.begin(), r.end() - 1, sub_slice, unpack_tuple_func(args));
     }
 
     void join(const reduce_sum_impl& child) {

From 3d62fa8e3f490576f47790b782728788b69aed03 Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Tue, 14 Jan 2020 01:52:52 -0500
Subject: [PATCH 035/189] loose stuff needed removed

---
 stan/math/prim/scal/functor/reduce_sum.hpp | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index 0f61247784e..e6f5fd38e8b 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -28,17 +28,9 @@ struct reduce_sum_impl {};
 template <typename ReduceFunction, typename M, typename T, typename... Args>
 struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<T>, M, T, Args...> {
   using vmapped_t = std::vector<M>;
-  using arg1_t = std::vector<Arg1>;
-  using arg2_t = std::vector<Arg2>;
-  using arg3_t = std::vector<Arg3>;
-  using arg4_t = std::vector<Arg4>;
   // todo(Steve): Need helper funcs for manipulating / iterating tuples
   std::tuple<std::vector<Args>...> arg_;
   const vmapped_t& vmapped_;
-  const arg1_t& arg1_;
-  const arg2_t& arg2_;
-  const arg3_t& arg3_;
-  const arg4_t& arg4_;
   T terms_sum_;
 
   // todo(Steve): put back recursive reducer

From cbcf42fad798015b317ba6dab7a6ddc5d9983aa2 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Tue, 14 Jan 2020 19:01:00 -0500
Subject: [PATCH 036/189] Added variadic implementation of rev parallel_sum

---
 stan/math/prim/scal.hpp                       |   1 +
 stan/math/prim/scal/functor/apply.hpp         |  50 ++
 stan/math/prim/scal/functor/reduce_sum.hpp    |  97 +--
 stan/math/rev/functor/adj_jac_apply.hpp       |  36 +-
 stan/math/rev/functor/reduce_sum.hpp          | 591 ++++++------------
 .../functor/parallel_v3_reduce_sum_test.cpp   | 180 +-----
 6 files changed, 303 insertions(+), 652 deletions(-)
 create mode 100644 stan/math/prim/scal/functor/apply.hpp

diff --git a/stan/math/prim/scal.hpp b/stan/math/prim/scal.hpp
index a07e1c628ef..b31762842ab 100644
--- a/stan/math/prim/scal.hpp
+++ b/stan/math/prim/scal.hpp
@@ -129,6 +129,7 @@
 #include <stan/math/prim/scal/fun/value_of.hpp>
 #include <stan/math/prim/scal/fun/value_of_rec.hpp>
 
+#include <stan/math/prim/scal/functor/apply.hpp>
 #include <stan/math/prim/scal/functor/reduce_sum.hpp>
 
 #include <stan/math/prim/prob/bernoulli_ccdf_log.hpp>
diff --git a/stan/math/prim/scal/functor/apply.hpp b/stan/math/prim/scal/functor/apply.hpp
new file mode 100644
index 00000000000..1f4b3af2e5d
--- /dev/null
+++ b/stan/math/prim/scal/functor/apply.hpp
@@ -0,0 +1,50 @@
+#ifndef STAN_MATH_PRIM_SCAL_FUNCTOR_APPLY_HPP
+#define STAN_MATH_PRIM_SCAL_FUNCTOR_APPLY_HPP
+
+#include <functional>
+#include <tuple>
+#include <utility>
+
+namespace stan {
+namespace math {
+/*
+ * Invoke the functor f with arguments given in t and indexed in the index
+ * sequence I
+ *
+ * @tparam F Type of functor
+ * @tparam Tuple Type of tuple containing arguments
+ * @tparam I 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
+ */
+template <class F, class Tuple, 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))...);
+}
+
+/*
+ * Call the functor f with the tuple of arguments t, like:
+ *
+ * f(std::get<0>(t), std::get<1>(t), ...)
+ *
+ * TODO: replace this with implementation in C++ std when C++17 is available
+ *
+ * @tparam F Type of functor
+ * @tparam Tuple Type of tuple containing arguments
+ * @param f functor callable
+ * @param t tuple of arguments
+ */
+template <class F, class Tuple>
+constexpr decltype(auto) apply(F&& f, Tuple&& t) {
+  return apply_impl(std::forward<F>(f), std::forward<Tuple>(t),
+                    std::make_index_sequence<
+                        std::tuple_size<std::remove_reference_t<Tuple>>{}>{});
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index e6f5fd38e8b..9005209aefd 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -19,59 +19,66 @@ namespace math {
 
 namespace internal {
 
-
-// base definition => compile error
-template <typename ReduceFunction, typename Enable = void, typename M, typename T, typename... Args>
-struct reduce_sum_impl {};
-
-// todo, double check if I need enable if here
-template <typename ReduceFunction, typename M, typename T, typename... Args>
-struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<T>, M, T, Args...> {
-  using vmapped_t = std::vector<M>;
-  // todo(Steve): Need helper funcs for manipulating / iterating tuples
-  std::tuple<std::vector<Args>...> arg_;
-  const vmapped_t& vmapped_;
-  T terms_sum_;
-
-  // todo(Steve): put back recursive reducer
-    reduce_sum_impl(const vmapped_t& vmapped, const T& init, Args&&... args)
-        : vmapped_(vmapped),
-          arg_(std::make_tuple(std::forward<Args>(args)...))
-          terms_sum_(value_of(init)) {}
-
-    reduce_sum_impl(reduce_sum_impl& other, tbb::split)
-        : vmapped_(other.vmapped_),
-        arg_(other.arg_),
-        terms_sum_(0.0) {}
+template <typename ReduceFunction, typename M, typename... Args>
+struct reduce_sum_impl {
+  struct recursive_reducer {
+    using vmapped_t = std::vector<M>;
+    std::tuple<const Args&...> args_tuple_;
+    const vmapped_t& vmapped_;
+    double sum_;
+
+    recursive_reducer(const vmapped_t& vmapped, const Args&... args)
+      : vmapped_(vmapped),
+	args_tuple_(args...),
+	sum_(0.0) {}
+
+    recursive_reducer(recursive_reducer& other, tbb::split)
+      : vmapped_(other.vmapped_),
+	args_tuple_(other.args_tuple_),
+	sum_(other.sum_) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty()) {
-        return;
+	return;
       }
-
+    
       auto start = vmapped_.begin();
       std::advance(start, r.begin());
       auto end = vmapped_.begin();
       std::advance(end, r.end());
-
+    
       const vmapped_t sub_slice(start, end);
-
-      terms_sum_ += ReduceFunction()(r.begin(), r.end() - 1, sub_slice, unpack_tuple_func(args));
+    
+      sum_ += apply([&](auto&&... args) {
+	  return ReduceFunction()(r.begin(), r.end() - 1, sub_slice, args...);
+	}, args_tuple_);
     }
-
-    void join(const reduce_sum_impl& child) {
-      terms_sum_ += child.terms_sum_;
+  
+    void join(const recursive_reducer& child) {
+      sum_ += child.sum_;
     }
+  };
 
-  // Todo: Better name for this than operator(), collect()?
-  template <typename... OtherArgs>
-  T operator()(const vmapped_t& vmapped, T init, std::size_t grainsize,
-               Args&&... args) const {
+  double operator()(const std::vector<M>& vmapped, std::size_t grainsize,
+	       const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
-    reduce_sum_impl<ReduceFunction, M, T, OtherArgs...> worker(vmapped, init, args...);
+
+    if (num_jobs == 0)
+      return 0.0;
+
+    recursive_reducer worker(vmapped, args...);
+
+#ifdef STAN_DETERMINISTIC
+    tbb::static_partitioner partitioner;
+    tbb::parallel_deterministic_reduce(
+        tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker,
+        partitioner);
+#else
     tbb::parallel_reduce(
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
-    return std::move(worker.terms_sum_);
+#endif
+
+    return worker.sum_;
   }
 };
 
@@ -82,17 +89,13 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<T>, M, T, Args...> {
  * that any internal state of the functor is causing trouble. Thus,
  * the functor must be default constructible without any arguments.
  */
-template <typename ReduceFunction, typename M, typename T, typename... Args>
-constexpr T reduce_sum(const std::vector<M>& vmapped, T init,
-                       std::size_t grainsize, Args&&... args) {
-  typedef T return_base_t;
-  // void here but need to figure out enable_if stuff
-  // We do this somewhere in the opencl code
-  return internal::reduce_sum_impl<ReduceFunction, M, T, void, Args...>()(
-    vmapped, init, grainsize, std::forward<Args>(args)...);
+template <typename ReduceFunction, typename M, typename... Args>
+constexpr double reduce_sum(const std::vector<M>& vmapped,
+			    std::size_t grainsize, const Args&... args) {
+  return internal::reduce_sum_impl<ReduceFunction, M, Args...>()
+    (vmapped, grainsize, args...);
 }
 
-
 }  // namespace math
 }  // namespace stan
 
diff --git a/stan/math/rev/functor/adj_jac_apply.hpp b/stan/math/rev/functor/adj_jac_apply.hpp
index 6041f634957..1384e98b554 100644
--- a/stan/math/rev/functor/adj_jac_apply.hpp
+++ b/stan/math/rev/functor/adj_jac_apply.hpp
@@ -13,40 +13,6 @@ namespace stan {
 namespace math {
 
 namespace internal {
-/**
- * Invoke the functor f with arguments given in t and indexed in the index
- * sequence I
- *
- * @tparam F Type of functor
- * @tparam Tuple Type of tuple containing arguments
- * @tparam I 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
- */
-template <class F, class Tuple, std::size_t... I>
-constexpr auto apply_impl(const F& f, const Tuple& t,
-                          std::index_sequence<I...> i) {
-  return f(std::get<I>(t)...);
-}
-
-/**
- * Call the functor f with the tuple of arguments t, like:
- *
- * f(std::get<0>(t), std::get<1>(t), ...)
- *
- * TODO: replace this with implementation in C++ std when C++17 is available
- *
- * @tparam F Type of functor
- * @tparam Tuple Type of tuple containing arguments
- * @param f functor callable
- * @param t tuple of arguments
- */
-template <class F, class Tuple>
-constexpr auto apply(const F& f, const Tuple& t) {
-  return apply_impl(f, t, std::make_index_sequence<std::tuple_size<Tuple>{}>{});
-}
 
 /**
  * Store the adjoint in y_vi[0] in y_adj
@@ -533,7 +499,7 @@ struct adj_jac_vari : public vari {
     internal::build_y_adj(y_vi_, M_, y_adj);
     auto y_adj_jacs = f_.multiply_adjoint_jacobian(is_var_, y_adj);
 
-    internal::apply(
+    apply(
         [this](auto&&... args) { this->accumulate_adjoints(args...); },
         y_adj_jacs);
   }
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index df5b3555319..6ef812127a0 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -14,405 +14,122 @@
 
 namespace stan {
 namespace math {
-
-template <typename T>
-struct value_type {
-  using type = double;
-};
-
-template <>
-struct value_type<int> {
-  using type = int;
-};
-
-template <template <typename> class T_struct, typename T_value>
-struct value_type<T_struct<T_value>> {
-  using type = T_struct<typename value_type<T_value>::type>;
-};
-
-template <typename T_value>
-struct value_type<std::vector<T_value>> {
-  using type = std::vector<typename value_type<T_value>::type>;
-};
-
-template <typename T_value, int R, int C>
-struct value_type<Eigen::Matrix<T_value, R, C>> {
-  using type = Eigen::Matrix<typename value_type<T_value>::type, R, C>;
-};
-
-// as_value is similar to value_of... with the difference that it
-// keeps nested container structures which is not the case for
-// value_of
-
-template <typename T>
-typename value_type<T>::type as_value(const T x) {
-  return typename value_type<T>::type(x);
-}
-
-template <typename T>
-typename value_type<std::vector<T>>::type as_value(const std::vector<T>& x) {
-  const size_t size = x.size();
-  typename value_type<std::vector<T>>::type result(size);
-  for (size_t i = 0; i != size; ++i) {
-    result[i] = as_value(x[i]);
-  }
-  return result;
-}
-
-inline double as_value(const var& x) { return x.vi_->val_; }
-
-template <typename T, int R, int C>
-inline Eigen::Matrix<typename value_type<T>::type, R, C> as_value(
-    const Eigen::Matrix<T, R, C>& M) {
-  Eigen::Matrix<typename value_type<T>::type, R, C> Md(M.rows(), M.cols());
-  for (int j = 0; j < M.cols(); j++) {
-    for (int i = 0; i < M.rows(); i++) {
-      Md(i, j) = as_value(M(i, j));
-    }
-  }
-  return Md;
-}
-
-template <int R, int C>
-inline const Eigen::Matrix<double, R, C>& as_value(
-    const Eigen::Matrix<double, R, C>& x) {
-  return x.val();
-}
-
-template <int R, int C>
-inline const Eigen::Matrix<int, R, C>& as_value(
-    const Eigen::Matrix<int, R, C>& x) {
-  return x.val();
-}
-
 namespace internal {
 
-inline int add_adjoint(const var& op, int offset_partials,
-                       Eigen::VectorXd& partials) {
-  partials(offset_partials) += op.vi_->adj_;
-  return ++offset_partials;
-}
-
-// template<typename Operand>
-inline int add_adjoint(const int op, int offset_partials,
-                       Eigen::VectorXd& partials) {
-  // no-op, does nothing
-  return offset_partials;
-}
-
-inline int add_adjoint(const double op, int offset_partials,
-                       Eigen::VectorXd& partials) {
-  // no-op, does nothing
-  return offset_partials;
-}
+template <class ReduceFunction, class M, typename... Args>
+struct reduce_sum_var_impl {
+  struct recursive_reducer {
+    size_t num_terms_;
+    const std::vector<M>& vmapped_;
+    std::tuple<const Args&...> args_tuple_;
 
-template <int R, int C>
-inline int add_adjoint(const Eigen::Matrix<double, R, C>& op,
-                       int offset_partials, Eigen::VectorXd& partials) {
-  return offset_partials;
-}
+    double sum_;
+    Eigen::VectorXd args_adjoints_;
 
-template <int R, int C>
-inline int add_adjoint(const Eigen::Matrix<int, R, C>& op, int offset_partials,
-                       Eigen::VectorXd& partials) {
-  return offset_partials;
-}
+    recursive_reducer(size_t num_terms, const std::vector<M>& vmapped, const Args&... args)
+      : num_terms_(num_terms),
+	vmapped_(vmapped),
+	args_tuple_(args...),
+	sum_(0.0),
+	args_adjoints_(Eigen::VectorXd::Zero(num_terms)) {}
 
-template <int R, int C>
-inline int add_adjoint(const Eigen::Matrix<var, R, C>& op, int offset_partials,
-                       Eigen::VectorXd& partials) {
-  for (int j = 0; j != op.cols(); ++j) {
-    for (int i = 0; i != op.rows(); ++i, ++offset_partials) {
-      partials(offset_partials) += op(i, j).vi_->adj_;
+    recursive_reducer(recursive_reducer& other, tbb::split)
+      : num_terms_(other.num_terms_),
+	vmapped_(other.vmapped_),
+	args_tuple_(other.args_tuple_),
+	sum_(other.sum_),
+	args_adjoints_(other.args_adjoints_) {}
+
+    template<typename T>
+    T& deep_copy(T& arg) {
+      return arg;
     }
-  }
-  return offset_partials;
-}
 
-template <typename Operand>
-inline int add_adjoint(const std::vector<Operand>& op, int offset_partials,
-                       Eigen::VectorXd& partials) {
-  for (size_t i = 0; i != op.size(); ++i) {
-    offset_partials = add_adjoint(op[i], offset_partials, partials);
-  }
-  return offset_partials;
-}
-
-inline vari** register_operands(const var& op, vari** varis) {
-  (*varis) = op.vi_;
-  return varis + 1;
-}
-
-template <int R, int C>
-inline vari** register_operands(const Eigen::Matrix<var, R, C>& M_op,
-                                vari** varis) {
-  const size_t size = M_op.size();
-  for (size_t i = 0; i != M_op.cols(); ++i) {
-    for (size_t j = 0; j != M_op.rows(); ++j, ++varis) {
-      *varis = M_op(j, i).vi_;
+    var deep_copy(const var& arg) {
+      return var(arg.val());
     }
-  }
-  return varis;
-}
-
-template <typename T>
-inline vari** register_operands(const std::vector<T>& op, vari** varis) {
-  const size_t size = op.size();
-  for (size_t i = 0; i != size; ++i) {
-    varis = register_operands(op[i], varis);
-  }
-  return varis;
-}
-
-/* this template is not picked up when it should??
-template <typename T_base>
-const std::vector< std::vector<T_base>> initialize_from_value(
-    const std::vector<std::vector<typename value_type<T_base>::type>>& value) {
-  std::vector<std::vector<T_base>> base(value.size(),
-std::vector<T_base>(value.size(), 0)); return base;
-}
-*/
-
-// use enable_if style to allow constuction of scalars and Eigen
-// things as well.
-template <typename T_base>
-const std::vector<T_base> initialize_from_value(
-    const std::vector<typename value_type<T_base>::type>& value) {
-  const std::vector<T_base> base(value.begin(), value.end());
-  return base;
-}
-
-/*
-template <typename T_base>
-const T_base initialize_from_value(const typename value_type<T_base>::type&
-value) { const T_base base(value.begin(), value.end()); return base;
-}
-*/
 
-/*
- * we should apply some meta magic to defined
- * local_operands_and_partials based on wether is_constant<T> is true
- * or false (instead of having this as if in every function). As a
- * work-around I have below partial template specializations which
- * give me the same effect with much less generality.
- */
-template <typename T>
-struct local_operand_and_partials {
-  using Op_t = std::vector<T>;
-  using Op_value_t = std::vector<typename value_type<T>::type>;
-  using Op_local_t = Op_t;
-  using Op_local_slice_t = Op_t;
-  using partials_t = Eigen::VectorXd;
-
-  const Op_t& op_;
-  std::shared_ptr<const Op_value_t> op_value_ptr_;
-  const Op_value_t& op_value_;
-  partials_t partials_;
-
-  explicit local_operand_and_partials(const Op_t& op)
-      : op_(op),
-        op_value_ptr_(new Op_value_t(as_value(op))),
-        op_value_(*op_value_ptr_),
-        partials_(Eigen::VectorXd::Zero(num_elements())) {}
-
-  local_operand_and_partials(const local_operand_and_partials<T>& other)
-      : op_(other.op_),
-        op_value_ptr_(other.op_value_ptr_),
-        op_value_(other.op_value_),
-        partials_(Eigen::VectorXd::Zero(num_elements())) {}
-
-  inline void add_local_adjoint(const Op_t& local_op, std::size_t offset = 0) {
-    if (!is_constant<T>::value) {
-      add_adjoint(local_op, offset, partials_);
+    std::vector<var> deep_copy(const std::vector<var>& arg) {
+      std::vector<var> copy(arg.size());
+      for(size_t i = 0; i < arg.size(); ++i) {
+	copy[i] = arg[i].val();
+      }
+      return copy;
     }
-  }
 
-  inline void add_other_adjoint(const local_operand_and_partials<T>& other) {
-    if (!is_constant<T>::value) {
-      partials_ += other.partials_;
+    template<int RowType, int ColType>
+    Eigen::Matrix<var, RowType, ColType> deep_copy(const Eigen::Matrix<var, RowType, ColType>& arg) {
+      Eigen::Matrix<var, RowType, ColType> copy(arg.size());
+      for(size_t i = 0; i < arg.size(); ++i) {
+	copy(i) = arg(i).val();
+      }
+      return copy;
     }
-  }
-
-  inline const Op_local_t local_op() const {
-    return initialize_from_value<T>(op_value_);
-  }
-
-  inline const Op_local_slice_t local_op(std::size_t start,
-                                         std::size_t end) const {
-    const Op_value_t slice(op_value_.begin() + start, op_value_.begin() + end);
-    return initialize_from_value<T>(slice);
-  }
-
-  inline std::size_t num_elements() const {
-    if (!is_constant<T>::value)
-      return stan::math::num_elements(op_value_);
-    return 0;
-  }
-
-  inline void build(vari** varis, double* partials) const {
-    if (!is_constant<T>::value) {
-      register_operands(op_, varis);
-      std::copy(partials_.data(), partials_.data() + partials_.size(),
-                partials);
+    
+    template<typename... Pargs>
+    void accumulate_adjoints(double *dest, const var& x, const Pargs&... args) {
+      *dest += x.adj();
+      accumulate_adjoints(dest + 1, args...);
+    }
+    
+    template<typename... Pargs>
+    void accumulate_adjoints(double *dest, const std::vector<var>& x, const Pargs&... args) {
+      for(size_t i = 0; i < x.size(); ++i) {
+	dest[i] += x[i].adj();
+      }
+      accumulate_adjoints(dest + x.size(), args...);
+    }
+    
+    template<typename... Pargs, int RowType, int ColType>
+    void accumulate_adjoints(double *dest, const Eigen::Matrix<var, RowType, ColType>& x, const Pargs&... args) {
+      for(size_t i = 0; i < x.size(); ++i) {
+	dest[i] += x(i).adj();
+      }
+      accumulate_adjoints(dest + x.size(), args...);
+    }
+    
+    template<typename R, typename... Pargs>
+    void accumulate_adjoints(double *dest, const R& x, const Pargs&... args) {
+      accumulate_adjoints(dest, args...);
     }
-  }
-};
-
-/* for types which are constants (non-vars), the implemtation can be
- * seriously simplified and based on constant refs being returned
- */
-
-template <>
-struct local_operand_and_partials<double> {
-  using Op_t = std::vector<double>;
-  using Op_local_t = const Op_t&;
-  using Op_local_slice_t = Op_t;
-
-  const Op_t& op_;
-
-  explicit local_operand_and_partials(const Op_t& op) : op_(op) {}
-
-  local_operand_and_partials(const local_operand_and_partials<double>& other)
-      : op_(other.op_) {}
-
-  inline void add_local_adjoint(const Op_t& local_op, std::size_t offset = 0) {}
-
-  inline void add_other_adjoint(
-      const local_operand_and_partials<double>& other) {}
-
-  inline Op_local_t local_op() const { return op_; }
-
-  inline const Op_local_slice_t local_op(std::size_t start,
-                                         std::size_t end) const {
-    const Op_local_slice_t slice(op_.begin() + start, op_.begin() + end);
-    return slice;
-  }
-
-  inline std::size_t num_elements() const { return 0; }
-
-  inline void build(vari** varis, double* partials) const {}
-};
-
-template <>
-struct local_operand_and_partials<int> {
-  using Op_t = std::vector<int>;
-  using Op_local_t = const Op_t&;
-  using Op_local_slice_t = Op_t;
-
-  const Op_t& op_;
-
-  explicit local_operand_and_partials(const Op_t& op) : op_(op) {}
-
-  local_operand_and_partials(const local_operand_and_partials<int>& other)
-      : op_(other.op_) {}
-
-  inline void add_local_adjoint(const Op_t& local_op, std::size_t offset = 0) {}
-
-  inline void add_other_adjoint(const local_operand_and_partials<int>& other) {}
-
-  inline Op_local_t local_op() const { return op_; }
-
-  inline const Op_local_slice_t local_op(std::size_t start,
-                                         std::size_t end) const {
-    const Op_local_slice_t slice(op_.begin() + start, op_.begin() + end);
-    return slice;
-  }
-
-  inline std::size_t num_elements() const { return 0; }
-
-  inline void build(vari** varis, double* partials) const {}
-};
-
-/*
-template <typename T, typename = void>
-struct local_operand_and_partials<T, > {
-};
-*/
-
-template <class ReduceFunction, class M, class T, class Arg1, class Arg2,
-          class Arg3, class Arg4>
-struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
-  using vmapped_t = std::vector<M>;
-  using arg1_t = std::vector<Arg1>;
-  using arg2_t = std::vector<Arg2>;
-  using arg3_t = std::vector<Arg3>;
-  using arg4_t = std::vector<Arg4>;
-
-  using vmapped_op_t = local_operand_and_partials<M>;
-  using arg1_local_op_t = local_operand_and_partials<Arg1>;
-  using arg2_local_op_t = local_operand_and_partials<Arg2>;
-  using arg3_local_op_t = local_operand_and_partials<Arg3>;
-  using arg4_local_op_t = local_operand_and_partials<Arg4>;
-
-  struct recursive_reducer {
-    vmapped_op_t& op_vmapped_;
-    arg1_local_op_t op_arg1_;
-    arg2_local_op_t op_arg2_;
-    arg3_local_op_t op_arg3_;
-    arg4_local_op_t op_arg4_;
-
-    const std::size_t num_vmapped_adjoints_per_element_;
-    double terms_sum_;
-
-    recursive_reducer(vmapped_op_t& op_vmapped,
-                      std::size_t num_vmapped_adjoints_per_element,
-                      const T& init, const arg1_t& arg1, const arg2_t& arg2,
-                      const arg3_t& arg3, const arg4_t& arg4)
-        : op_vmapped_(op_vmapped),
-          op_arg1_(arg1),
-          op_arg2_(arg2),
-          op_arg3_(arg3),
-          op_arg4_(arg4),
-          num_vmapped_adjoints_per_element_(num_vmapped_adjoints_per_element),
-          terms_sum_(as_value(init)) {}
 
-    recursive_reducer(recursive_reducer& other, tbb::split)
-        : op_vmapped_(other.op_vmapped_),
-          op_arg1_(other.op_arg1_),
-          op_arg2_(other.op_arg2_),
-          op_arg3_(other.op_arg3_),
-          op_arg4_(other.op_arg4_),
-          num_vmapped_adjoints_per_element_(
-              other.num_vmapped_adjoints_per_element_),
-          terms_sum_(0.0) {}
+    void accumulate_adjoints(double *) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty())
         return;
 
+      auto start = vmapped_.begin();
+      std::advance(start, r.begin());
+      auto end = vmapped_.begin();
+      std::advance(end, r.end());
+      
+      const std::vector<M> sub_slice(start, end);
+      
       try {
         start_nested();
 
         // create a deep copy of all var's so that these are not
         // linked to any outer AD tree
-
-        const typename vmapped_op_t::Op_local_slice_t local_sub_slice
-            = op_vmapped_.local_op(r.begin(), r.end());
-        const typename arg1_local_op_t::Op_local_t local_arg1
-            = op_arg1_.local_op();
-        const typename arg2_local_op_t::Op_local_t local_arg2
-            = op_arg2_.local_op();
-        const typename arg3_local_op_t::Op_local_t local_arg3
-            = op_arg3_.local_op();
-        const typename arg4_local_op_t::Op_local_t local_arg4
-            = op_arg4_.local_op();
-
-        T sub_sum_v
-            = ReduceFunction()(r.begin(), r.end() - 1, local_sub_slice,
-                               local_arg1, local_arg2, local_arg3, local_arg4);
-
-        sub_sum_v.grad();
-
-        terms_sum_ += sub_sum_v.val();
-
-        op_vmapped_.add_local_adjoint(
-            local_sub_slice, num_vmapped_adjoints_per_element_ * r.begin());
-
-        op_arg1_.add_local_adjoint(local_arg1);
-        op_arg2_.add_local_adjoint(local_arg2);
-        op_arg3_.add_local_adjoint(local_arg3);
-        op_arg4_.add_local_adjoint(local_arg4);
-
+	auto args_tuple_local_copy = apply([&](auto&&... args) {
+	    return std::make_tuple(deep_copy(args)...);
+	  }, args_tuple_);
+
+	var sub_sum_v = apply([&](auto&&... args) {
+	    return ReduceFunction()(r.begin(), r.end() - 1, sub_slice,
+				    args...);
+	  },
+	  args_tuple_local_copy);
+      
+	sub_sum_v.grad();
+	
+	sum_ += sub_sum_v.val();
+	
+	// This should accumulate the adjoints from args_tuple_local_copy into
+	//  the memory of args_adjoints_
+	apply([&](auto&&... args) {
+	    accumulate_adjoints(args_adjoints_.data(), args...);
+	  }, args_tuple_local_copy);
       } catch (const std::exception& e) {
         recover_memory_nested();
         throw;
@@ -420,28 +137,86 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
       recover_memory_nested();
     }
 
-    void join(const recursive_reducer& child) {
-      terms_sum_ += child.terms_sum_;
-
-      op_arg1_.add_other_adjoint(child.op_arg1_);
-      op_arg2_.add_other_adjoint(child.op_arg2_);
-      op_arg3_.add_other_adjoint(child.op_arg3_);
-      op_arg4_.add_other_adjoint(child.op_arg4_);
+    void join(const recursive_reducer& rhs) {
+      sum_ += rhs.sum_;
+      args_adjoints_ += rhs.args_adjoints_;
     }
   };
 
-  T operator()(const vmapped_t& vmapped, T init, std::size_t grainsize,
-               const arg1_t& arg1, const arg2_t& arg2, const arg3_t& arg3,
-               const arg4_t& arg4) const {
+  template <typename... Pargs, int RowType, int ColType>
+  size_t count_var_impl(size_t count, const Eigen::Matrix<var, RowType, ColType>& x,
+		      const Pargs&... args) const {
+    return count_var_impl(count + x.size(), args...);
+  }
+    
+  template <typename... Pargs>
+  size_t count_var_impl(size_t count, const std::vector<var>& x,
+		      const Pargs&... args) const {
+    return count_var_impl(count + x.size(), args...);
+  }
+    
+  template <typename... Pargs>
+  size_t count_var_impl(size_t count, const var& x, const Pargs&... args) const {
+    return count_var_impl(count + 1, args...);
+  }
+    
+  template <typename R, typename... Pargs>
+  size_t count_var_impl(size_t count, const R& x, const Pargs&... args) const {
+    return count_var_impl(count, args...);
+  }
+
+  size_t count_var_impl(size_t count) const { return count; }
+
+  /**
+   * Count the number of scalars of type T in the input argument list
+   *
+   * @tparam Pargs Types of input arguments
+   * @return Number of scalars of type T in input
+   */
+  template <typename... Pargs>
+  size_t count_var(const Pargs&... args) const {
+    return count_var_impl(0, args...);
+  }
+
+  template<typename... Pargs>
+  void save_varis(vari **dest, const var& x, const Pargs&... args) const {
+    *dest = x.vi_;
+    save_varis(dest + 1, args...);
+  }
+    
+  template<typename... Pargs>
+  void save_varis(vari **dest, const std::vector<var>& x, const Pargs&... args) const {
+    for(size_t i = 0; i < x.size(); ++i) {
+      dest[i] = x[i].vi_;
+    }
+    save_varis(dest + x.size(), args...);
+  }
+    
+  template<typename... Pargs, int RowType, int ColType>
+  void save_varis(vari **dest, const Eigen::Matrix<var, RowType, ColType>& x, const Pargs&... args) const {
+    for(size_t i = 0; i < x.size(); ++i) {
+      dest[i] = x(i).vi_;
+    }
+    save_varis(dest + x.size(), args...);
+  }
+    
+  template<typename R, typename... Pargs>
+  void save_varis(vari **dest, const R& x, const Pargs&... args) const {
+    save_varis(dest, args...);
+  }
+  
+  void save_varis(vari **) const {}
+
+  var operator()(const std::vector<M>& vmapped, std::size_t grainsize,
+		 const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
     if (num_jobs == 0)
-      return init;
+      return var(0.0);
 
-    vmapped_op_t op_vmapped(vmapped);
+    const std::size_t num_terms = count_var(args...);
 
-    recursive_reducer worker(op_vmapped, num_elements(vmapped[0]), init, arg1,
-                             arg2, arg3, arg4);
+    recursive_reducer worker(num_terms, vmapped, args...);
 
 #ifdef STAN_DETERMINISTIC
     tbb::static_partitioner partitioner;
@@ -453,39 +228,35 @@ struct reduce_sum_impl<ReduceFunction, M, T, Arg1, Arg2, Arg3, Arg4, var> {
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
 #endif
 
-    std::vector<std::size_t> num_terms_arg(5, 0);
-
-    num_terms_arg[0] = op_vmapped.num_elements();
-    num_terms_arg[1] = worker.op_arg1_.num_elements();
-    num_terms_arg[2] = worker.op_arg2_.num_elements();
-    num_terms_arg[3] = worker.op_arg3_.num_elements();
-    num_terms_arg[4] = worker.op_arg4_.num_elements();
-
-    const std::size_t num_terms = sum(num_terms_arg);
-
     vari** varis
         = ChainableStack::instance_->memalloc_.alloc_array<vari*>(num_terms);
     double* partials
         = ChainableStack::instance_->memalloc_.alloc_array<double>(num_terms);
 
-    std::size_t idx = 0;
+    save_varis(varis, args...);
 
-    op_vmapped.build(&varis[idx], &partials[idx]);
-    idx += num_terms_arg[0];
-    worker.op_arg1_.build(&varis[idx], &partials[idx]);
-    idx += num_terms_arg[1];
-    worker.op_arg2_.build(&varis[idx], &partials[idx]);
-    idx += num_terms_arg[2];
-    worker.op_arg3_.build(&varis[idx], &partials[idx]);
-    idx += num_terms_arg[3];
-    worker.op_arg4_.build(&varis[idx], &partials[idx]);
+    for(size_t i = 0; i < num_terms; ++i) {
+      partials[i] = worker.args_adjoints_(i);
+    }
 
-    return var(new precomputed_gradients_vari(worker.terms_sum_, num_terms,
+    return var(new precomputed_gradients_vari(worker.sum_, num_terms,
                                               varis, partials));
   }
 };
 }  // namespace internal
 
+/*
+ * Note that the ReduceFunction is only passed in as type to prohibit
+ * that any internal state of the functor is causing trouble. Thus,
+ * the functor must be default constructible without any arguments.
+ */
+template <typename ReduceFunction, typename M, typename... Args>
+var reduce_sum_var(const std::vector<M>& vmapped,
+		   std::size_t grainsize, const Args&... args) {
+  return internal::reduce_sum_var_impl<ReduceFunction, M, Args...>()
+    (vmapped, grainsize, args...);
+}
+
 }  // namespace math
 }  // namespace stan
 
diff --git a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
index 470798fda62..e04498f6d4b 100644
--- a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
@@ -37,18 +37,15 @@ TEST(v3_reduce_sum, value) {
 
   typedef boost::counting_iterator<std::size_t> count_iter;
 
-  double poisson_lpdf = stan::math::reduce_sum<count_lpdf<double>>(
-      data, 0.0, 5, vlambda_d, idata);
+  double poisson_lpdf = stan::math::reduce_sum<count_lpdf<double>>(data, 5, vlambda_d, idata);
 
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
 
   EXPECT_FLOAT_EQ(poisson_lpdf, poisson_lpdf_ref);
 
   std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref << std::endl;
-  ;
 
   std::cout << "value of poisson lpdf : " << poisson_lpdf << std::endl;
-  ;
 }
 
 TEST(v3_reduce_sum, gradient) {
@@ -70,8 +67,8 @@ TEST(v3_reduce_sum, gradient) {
   std::vector<int> idata;
   std::vector<var> vlambda_v(1, lambda_v);
 
-  var poisson_lpdf = stan::math::reduce_sum<count_lpdf<var>>(data, var(0.0), 5,
-                                                             vlambda_v, idata);
+  var poisson_lpdf = stan::math::reduce_sum_var<count_lpdf<var>>(data, 5,
+								 vlambda_v, idata);
 
   var lambda_ref = lambda_d;
   var poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_ref);
@@ -89,14 +86,13 @@ TEST(v3_reduce_sum, gradient) {
 
   std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref.val()
             << std::endl;
-  ;
+
   std::cout << "ref gradient wrt to lambda: " << lambda_ref_adj << std::endl;
-  ;
 
   std::cout << "value of poisson lpdf : " << poisson_lpdf.val() << std::endl;
-  ;
+
   std::cout << "gradient wrt to lambda: " << lambda_adj << std::endl;
-  ;
+
   stan::math::recover_memory();
 }
 
@@ -113,41 +109,10 @@ struct nesting_count_lpdf {
                       const std::vector<int>& sub_slice,
                       const std::vector<T>& lambda,
                       const std::vector<int>& idata) const {
-    return stan::math::reduce_sum<count_lpdf<T>>(sub_slice, T(0.0), 5, lambda,
-                                                 idata);
+    return stan::math::reduce_sum_var<count_lpdf<T>>(sub_slice, 5, lambda, idata);
   }
 };
 
-TEST(v3_reduce_sum, nesting_value) {
-  stan::math::init_threadpool_tbb();
-
-  double lambda_d = 10.0;
-  const std::size_t elems = 10000;
-  const std::size_t num_iter = 1000;
-  std::vector<int> data(elems);
-
-  for (std::size_t i = 0; i != elems; ++i)
-    data[i] = i;
-
-  std::vector<int> idata;
-  std::vector<double> vlambda_d(1, lambda_d);
-
-  typedef boost::counting_iterator<std::size_t> count_iter;
-
-  double poisson_lpdf = stan::math::reduce_sum<count_lpdf<double>>(
-      data, 0.0, 5, vlambda_d, idata);
-
-  double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
-
-  EXPECT_FLOAT_EQ(poisson_lpdf, poisson_lpdf_ref);
-
-  std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref << std::endl;
-  ;
-
-  std::cout << "value of poisson lpdf : " << poisson_lpdf << std::endl;
-  ;
-}
-
 TEST(v3_reduce_sum, nesting_gradient) {
   stan::math::init_threadpool_tbb();
 
@@ -167,8 +132,8 @@ TEST(v3_reduce_sum, nesting_gradient) {
   std::vector<int> idata;
   std::vector<var> vlambda_v(1, lambda_v);
 
-  var poisson_lpdf = stan::math::reduce_sum<nesting_count_lpdf<var>>(
-      data, var(0.0), 5, vlambda_v, idata);
+  var poisson_lpdf = stan::math::reduce_sum_var<nesting_count_lpdf<var>>(
+      data, 5, vlambda_v, idata);
 
   var lambda_ref = lambda_d;
   var poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_ref);
@@ -186,14 +151,12 @@ TEST(v3_reduce_sum, nesting_gradient) {
 
   std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref.val()
             << std::endl;
-  ;
+
   std::cout << "ref gradient wrt to lambda: " << lambda_ref_adj << std::endl;
-  ;
 
   std::cout << "value of poisson lpdf : " << poisson_lpdf.val() << std::endl;
-  ;
+
   std::cout << "gradient wrt to lambda: " << lambda_adj << std::endl;
-  ;
 
   stan::math::recover_memory();
 }
@@ -247,8 +210,8 @@ TEST(v3_reduce_sum, grouped_gradient) {
 
   var lambda_v = vlambda_v[0];
 
-  var poisson_lpdf = stan::math::reduce_sum<grouped_count_lpdf<var>>(
-      data, var(0.0), 5, vlambda_v, gidx);
+  var poisson_lpdf = stan::math::reduce_sum_var<grouped_count_lpdf<var>>(
+      data, 5, vlambda_v, gidx);
 
   std::vector<var> vref_lambda_v;
   for (std::size_t i = 0; i != elems; ++i) {
@@ -271,17 +234,17 @@ TEST(v3_reduce_sum, grouped_gradient) {
 
   std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref.val()
             << std::endl;
-  ;
+
   std::cout << "ref gradient wrt to lambda: " << lambda_ref_adj << std::endl;
-  ;
 
   std::cout << "value of poisson lpdf : " << poisson_lpdf.val() << std::endl;
-  ;
+
   std::cout << "gradient wrt to lambda: " << lambda_adj << std::endl;
-  ;
+
   stan::math::recover_memory();
 }
 
+/*
 // ********************************
 // slice over the grouping variable which is a var
 // ********************************
@@ -319,6 +282,7 @@ TEST(v3_reduce_sum, slice_group_gradient) {
   std::vector<int> gidx(elems);
   std::vector<int> gsidx(groups + 1);
 
+  
   for (std::size_t i = 0, k = 0; i != groups; ++i) {
     gsidx[i] = k;
     for (std::size_t j = 0; j != elems_per_group; ++j, ++k) {
@@ -337,8 +301,8 @@ TEST(v3_reduce_sum, slice_group_gradient) {
 
   var lambda_v = vlambda_v[0];
 
-  var poisson_lpdf = stan::math::reduce_sum<slice_group_count_lpdf<var>>(
-      vlambda_v, var(0.0), 5, data, gsidx);
+  var poisson_lpdf = stan::math::reduce_sum_var<slice_group_count_lpdf<var>>(
+      vlambda_v, 5, data, gsidx);
 
   std::vector<var> vref_lambda_v;
   for (std::size_t i = 0; i != elems; ++i) {
@@ -371,108 +335,4 @@ TEST(v3_reduce_sum, slice_group_gradient) {
   ;
   stan::math::recover_memory();
 }
-
-// ********************************
-// slice over the grouping variable which is a var and the slicing
-// variable itself has more structure than just being a vector of vars.
-// ********************************
-
-template <typename T>
-struct slice_groupNested_count_lpdf {
-  slice_groupNested_count_lpdf() {}
-
-  // does the reduction in the sub-slice start to end
-  inline T operator()(std::size_t start, std::size_t end,
-                      const std::vector<std::vector<T>>& lambda_slice,
-                      const std::vector<int>& y,
-                      const std::vector<int>& gsidx) const {
-    const std::size_t num_groups = end - start + 1;
-    T result = 0.0;
-    for (std::size_t i = 0; i != num_groups; ++i) {
-      std::vector<int> y_group(y.begin() + gsidx[start + i],
-                               y.begin() + gsidx[start + i + 1]);
-      result += stan::math::poisson_lpmf(
-          y_group, lambda_slice[i][0] + lambda_slice[i][1]);
-    }
-    return result;
-  }
-};
-
-/* this should be supported if possible. it requires to allow
- * initialization from nested structures and it requires that the
- * offset handling is correct in the slicing code which right now
- * assumes that each array element which we slice only has a single adjoint.
- */
-/*
-TEST(v3_reduce_sum, slice_groupNested_gradient) {
-  stan::math::init_threadpool_tbb();
-
-  double lambda_d = 10.0;
-  const std::size_t groups = 10;
-  const std::size_t elems_per_group = 1000;
-  const std::size_t elems = groups * elems_per_group;
-  const std::size_t num_iter = 1000;
-
-  std::vector<int> data(elems);
-  std::vector<int> gidx(elems);
-  std::vector<int> gsidx(groups + 1);
-
-  for (std::size_t i = 0, k = 0; i != groups; ++i) {
-    gsidx[i] = k;
-    for (std::size_t j = 0; j != elems_per_group; ++j, ++k) {
-      data[k] = k;
-      gidx[k] = i;
-    }
-    gsidx[i + 1] = k;
-  }
-
-  using stan::math::var;
-
-  std::vector<std::vector<var>> vlambda_v;
-
-  for (std::size_t i = 0; i != groups; ++i) {
-    var l1 = i + 0.2;
-    var l2 = 2*i + 0.2;
-    std::vector<var> terms;
-    terms.push_back(l1);
-    terms.push_back(l2);
-    vlambda_v.push_back(terms);
-  }
-
-  var lambda_v = vlambda_v[0][0];
-
-  var poisson_lpdf = stan::math::reduce_sum<slice_groupNested_count_lpdf<var>>(
-      vlambda_v, var(0.0), 5, data, gsidx);
-
-  std::vector<var> vref_lambda_v;
-  for (std::size_t i = 0; i != elems; ++i) {
-    vref_lambda_v.push_back(vlambda_v[gidx[i]][0] + vlambda_v[gidx[i]][1]);
-  }
-  var lambda_ref = vlambda_v[0];
-
-  var poisson_lpdf_ref = stan::math::poisson_lpmf(data, vref_lambda_v);
-
-  EXPECT_FLOAT_EQ(value_of(poisson_lpdf), value_of(poisson_lpdf_ref));
-
-  stan::math::grad(poisson_lpdf_ref.vi_);
-  const double lambda_ref_adj = lambda_ref.adj();
-
-  stan::math::set_zero_all_adjoints();
-  stan::math::grad(poisson_lpdf.vi_);
-  const double lambda_adj = lambda_v.adj();
-
-  EXPECT_FLOAT_EQ(lambda_adj, lambda_ref_adj);
-
-  std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref.val()
-            << std::endl;
-  ;
-  std::cout << "ref gradient wrt to lambda: " << lambda_ref_adj << std::endl;
-  ;
-
-  std::cout << "value of poisson lpdf : " << poisson_lpdf.val() << std::endl;
-  ;
-  std::cout << "gradient wrt to lambda: " << lambda_adj << std::endl;
-  ;
-  stan::math::recover_memory();
-}
 */

From 8f90d8c99cfa5bff5ddc4d97bd3a7a5c50797abc Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Tue, 14 Jan 2020 22:34:33 -0500
Subject: [PATCH 037/189] Adds enable_ifs to reduce_sum_impl

---
 stan/math/prim/scal/functor/reduce_sum.hpp    | 21 +++++----
 stan/math/rev/functor/reduce_sum.hpp          | 47 +++++++------------
 .../functor/parallel_v3_reduce_sum_test.cpp   | 12 ++---
 3 files changed, 37 insertions(+), 43 deletions(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index 9005209aefd..2cbf4ea898e 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -19,8 +19,12 @@ namespace math {
 
 namespace internal {
 
-template <typename ReduceFunction, typename M, typename... Args>
-struct reduce_sum_impl {
+template <typename ReduceFunction, typename Enable, typename ReturnType, typename M, typename... Args>
+struct reduce_sum_impl {};
+
+
+template <typename ReduceFunction, typename ReturnType, typename M, typename... Args>
+struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>, ReturnType, M, Args...> {
   struct recursive_reducer {
     using vmapped_t = std::vector<M>;
     std::tuple<const Args&...> args_tuple_;
@@ -41,19 +45,19 @@ struct reduce_sum_impl {
       if (r.empty()) {
 	return;
       }
-    
+
       auto start = vmapped_.begin();
       std::advance(start, r.begin());
       auto end = vmapped_.begin();
       std::advance(end, r.end());
-    
+
       const vmapped_t sub_slice(start, end);
-    
+
       sum_ += apply([&](auto&&... args) {
 	  return ReduceFunction()(r.begin(), r.end() - 1, sub_slice, args...);
 	}, args_tuple_);
     }
-  
+
     void join(const recursive_reducer& child) {
       sum_ += child.sum_;
     }
@@ -90,9 +94,10 @@ struct reduce_sum_impl {
  * the functor must be default constructible without any arguments.
  */
 template <typename ReduceFunction, typename M, typename... Args>
-constexpr double reduce_sum(const std::vector<M>& vmapped,
+constexpr auto reduce_sum(const std::vector<M>& vmapped,
 			    std::size_t grainsize, const Args&... args) {
-  return internal::reduce_sum_impl<ReduceFunction, M, Args...>()
+  using return_type = return_type_t<Args...>;
+  return internal::reduce_sum_impl<ReduceFunction, void, return_type, M, Args...>()
     (vmapped, grainsize, args...);
 }
 
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 6ef812127a0..a2740a11e9c 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -16,8 +16,8 @@ namespace stan {
 namespace math {
 namespace internal {
 
-template <class ReduceFunction, class M, typename... Args>
-struct reduce_sum_var_impl {
+template <typename ReduceFunction, typename ReturnType, typename M, typename... Args>
+struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M, Args...> {
   struct recursive_reducer {
     size_t num_terms_;
     const std::vector<M>& vmapped_;
@@ -65,13 +65,13 @@ struct reduce_sum_var_impl {
       }
       return copy;
     }
-    
+
     template<typename... Pargs>
     void accumulate_adjoints(double *dest, const var& x, const Pargs&... args) {
       *dest += x.adj();
       accumulate_adjoints(dest + 1, args...);
     }
-    
+
     template<typename... Pargs>
     void accumulate_adjoints(double *dest, const std::vector<var>& x, const Pargs&... args) {
       for(size_t i = 0; i < x.size(); ++i) {
@@ -79,7 +79,7 @@ struct reduce_sum_var_impl {
       }
       accumulate_adjoints(dest + x.size(), args...);
     }
-    
+
     template<typename... Pargs, int RowType, int ColType>
     void accumulate_adjoints(double *dest, const Eigen::Matrix<var, RowType, ColType>& x, const Pargs&... args) {
       for(size_t i = 0; i < x.size(); ++i) {
@@ -87,7 +87,7 @@ struct reduce_sum_var_impl {
       }
       accumulate_adjoints(dest + x.size(), args...);
     }
-    
+
     template<typename R, typename... Pargs>
     void accumulate_adjoints(double *dest, const R& x, const Pargs&... args) {
       accumulate_adjoints(dest, args...);
@@ -103,9 +103,9 @@ struct reduce_sum_var_impl {
       std::advance(start, r.begin());
       auto end = vmapped_.begin();
       std::advance(end, r.end());
-      
+
       const std::vector<M> sub_slice(start, end);
-      
+
       try {
         start_nested();
 
@@ -120,11 +120,11 @@ struct reduce_sum_var_impl {
 				    args...);
 	  },
 	  args_tuple_local_copy);
-      
+
 	sub_sum_v.grad();
-	
+
 	sum_ += sub_sum_v.val();
-	
+
 	// This should accumulate the adjoints from args_tuple_local_copy into
 	//  the memory of args_adjoints_
 	apply([&](auto&&... args) {
@@ -148,18 +148,18 @@ struct reduce_sum_var_impl {
 		      const Pargs&... args) const {
     return count_var_impl(count + x.size(), args...);
   }
-    
+
   template <typename... Pargs>
   size_t count_var_impl(size_t count, const std::vector<var>& x,
 		      const Pargs&... args) const {
     return count_var_impl(count + x.size(), args...);
   }
-    
+
   template <typename... Pargs>
   size_t count_var_impl(size_t count, const var& x, const Pargs&... args) const {
     return count_var_impl(count + 1, args...);
   }
-    
+
   template <typename R, typename... Pargs>
   size_t count_var_impl(size_t count, const R& x, const Pargs&... args) const {
     return count_var_impl(count, args...);
@@ -183,7 +183,7 @@ struct reduce_sum_var_impl {
     *dest = x.vi_;
     save_varis(dest + 1, args...);
   }
-    
+
   template<typename... Pargs>
   void save_varis(vari **dest, const std::vector<var>& x, const Pargs&... args) const {
     for(size_t i = 0; i < x.size(); ++i) {
@@ -191,7 +191,7 @@ struct reduce_sum_var_impl {
     }
     save_varis(dest + x.size(), args...);
   }
-    
+
   template<typename... Pargs, int RowType, int ColType>
   void save_varis(vari **dest, const Eigen::Matrix<var, RowType, ColType>& x, const Pargs&... args) const {
     for(size_t i = 0; i < x.size(); ++i) {
@@ -199,12 +199,12 @@ struct reduce_sum_var_impl {
     }
     save_varis(dest + x.size(), args...);
   }
-    
+
   template<typename R, typename... Pargs>
   void save_varis(vari **dest, const R& x, const Pargs&... args) const {
     save_varis(dest, args...);
   }
-  
+
   void save_varis(vari **) const {}
 
   var operator()(const std::vector<M>& vmapped, std::size_t grainsize,
@@ -245,17 +245,6 @@ struct reduce_sum_var_impl {
 };
 }  // namespace internal
 
-/*
- * Note that the ReduceFunction is only passed in as type to prohibit
- * that any internal state of the functor is causing trouble. Thus,
- * the functor must be default constructible without any arguments.
- */
-template <typename ReduceFunction, typename M, typename... Args>
-var reduce_sum_var(const std::vector<M>& vmapped,
-		   std::size_t grainsize, const Args&... args) {
-  return internal::reduce_sum_var_impl<ReduceFunction, M, Args...>()
-    (vmapped, grainsize, args...);
-}
 
 }  // namespace math
 }  // namespace stan
diff --git a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
index e04498f6d4b..f08bc2c21ef 100644
--- a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
@@ -67,7 +67,7 @@ TEST(v3_reduce_sum, gradient) {
   std::vector<int> idata;
   std::vector<var> vlambda_v(1, lambda_v);
 
-  var poisson_lpdf = stan::math::reduce_sum_var<count_lpdf<var>>(data, 5,
+  var poisson_lpdf = stan::math::reduce_sum<count_lpdf<var>>(data, 5,
 								 vlambda_v, idata);
 
   var lambda_ref = lambda_d;
@@ -109,7 +109,7 @@ struct nesting_count_lpdf {
                       const std::vector<int>& sub_slice,
                       const std::vector<T>& lambda,
                       const std::vector<int>& idata) const {
-    return stan::math::reduce_sum_var<count_lpdf<T>>(sub_slice, 5, lambda, idata);
+    return stan::math::reduce_sum<count_lpdf<T>>(sub_slice, 5, lambda, idata);
   }
 };
 
@@ -132,7 +132,7 @@ TEST(v3_reduce_sum, nesting_gradient) {
   std::vector<int> idata;
   std::vector<var> vlambda_v(1, lambda_v);
 
-  var poisson_lpdf = stan::math::reduce_sum_var<nesting_count_lpdf<var>>(
+  var poisson_lpdf = stan::math::reduce_sum<nesting_count_lpdf<var>>(
       data, 5, vlambda_v, idata);
 
   var lambda_ref = lambda_d;
@@ -210,7 +210,7 @@ TEST(v3_reduce_sum, grouped_gradient) {
 
   var lambda_v = vlambda_v[0];
 
-  var poisson_lpdf = stan::math::reduce_sum_var<grouped_count_lpdf<var>>(
+  var poisson_lpdf = stan::math::reduce_sum<grouped_count_lpdf<var>>(
       data, 5, vlambda_v, gidx);
 
   std::vector<var> vref_lambda_v;
@@ -282,7 +282,7 @@ TEST(v3_reduce_sum, slice_group_gradient) {
   std::vector<int> gidx(elems);
   std::vector<int> gsidx(groups + 1);
 
-  
+
   for (std::size_t i = 0, k = 0; i != groups; ++i) {
     gsidx[i] = k;
     for (std::size_t j = 0; j != elems_per_group; ++j, ++k) {
@@ -301,7 +301,7 @@ TEST(v3_reduce_sum, slice_group_gradient) {
 
   var lambda_v = vlambda_v[0];
 
-  var poisson_lpdf = stan::math::reduce_sum_var<slice_group_count_lpdf<var>>(
+  var poisson_lpdf = stan::math::reduce_sum<slice_group_count_lpdf<var>>(
       vlambda_v, 5, data, gsidx);
 
   std::vector<var> vref_lambda_v;

From 617d6e2aa80e61d239fc088ba4c30e381a05d527 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Wed, 15 Jan 2020 03:38:15 +0000
Subject: [PATCH 038/189] [Jenkins] auto-formatting by clang-format version
 5.0.0-3~16.04.1 (tags/RELEASE_500/final)

---
 stan/math/prim/scal/functor/reduce_sum.hpp    |  44 ++---
 stan/math/rev/functor/adj_jac_apply.hpp       |   5 +-
 stan/math/rev/functor/reduce_sum.hpp          | 161 ++++++++++--------
 .../functor/parallel_v3_reduce_sum_test.cpp   |   7 +-
 4 files changed, 114 insertions(+), 103 deletions(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index 2cbf4ea898e..0369064fe97 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -19,12 +19,14 @@ namespace math {
 
 namespace internal {
 
-template <typename ReduceFunction, typename Enable, typename ReturnType, typename M, typename... Args>
+template <typename ReduceFunction, typename Enable, typename ReturnType,
+          typename M, typename... Args>
 struct reduce_sum_impl {};
 
-
-template <typename ReduceFunction, typename ReturnType, typename M, typename... Args>
-struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>, ReturnType, M, Args...> {
+template <typename ReduceFunction, typename ReturnType, typename M,
+          typename... Args>
+struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
+                       ReturnType, M, Args...> {
   struct recursive_reducer {
     using vmapped_t = std::vector<M>;
     std::tuple<const Args&...> args_tuple_;
@@ -32,18 +34,16 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>, ReturnT
     double sum_;
 
     recursive_reducer(const vmapped_t& vmapped, const Args&... args)
-      : vmapped_(vmapped),
-	args_tuple_(args...),
-	sum_(0.0) {}
+        : vmapped_(vmapped), args_tuple_(args...), sum_(0.0) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-      : vmapped_(other.vmapped_),
-	args_tuple_(other.args_tuple_),
-	sum_(other.sum_) {}
+        : vmapped_(other.vmapped_),
+          args_tuple_(other.args_tuple_),
+          sum_(other.sum_) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty()) {
-	return;
+        return;
       }
 
       auto start = vmapped_.begin();
@@ -53,18 +53,18 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>, ReturnT
 
       const vmapped_t sub_slice(start, end);
 
-      sum_ += apply([&](auto&&... args) {
-	  return ReduceFunction()(r.begin(), r.end() - 1, sub_slice, args...);
-	}, args_tuple_);
+      sum_ += apply(
+          [&](auto&&... args) {
+            return ReduceFunction()(r.begin(), r.end() - 1, sub_slice, args...);
+          },
+          args_tuple_);
     }
 
-    void join(const recursive_reducer& child) {
-      sum_ += child.sum_;
-    }
+    void join(const recursive_reducer& child) { sum_ += child.sum_; }
   };
 
   double operator()(const std::vector<M>& vmapped, std::size_t grainsize,
-	       const Args&... args) const {
+                    const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
     if (num_jobs == 0)
@@ -94,11 +94,11 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>, ReturnT
  * the functor must be default constructible without any arguments.
  */
 template <typename ReduceFunction, typename M, typename... Args>
-constexpr auto reduce_sum(const std::vector<M>& vmapped,
-			    std::size_t grainsize, const Args&... args) {
+constexpr auto reduce_sum(const std::vector<M>& vmapped, std::size_t grainsize,
+                          const Args&... args) {
   using return_type = return_type_t<Args...>;
-  return internal::reduce_sum_impl<ReduceFunction, void, return_type, M, Args...>()
-    (vmapped, grainsize, args...);
+  return internal::reduce_sum_impl<ReduceFunction, void, return_type, M,
+                                   Args...>()(vmapped, grainsize, args...);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/adj_jac_apply.hpp b/stan/math/rev/functor/adj_jac_apply.hpp
index 1384e98b554..c19b3487f0b 100644
--- a/stan/math/rev/functor/adj_jac_apply.hpp
+++ b/stan/math/rev/functor/adj_jac_apply.hpp
@@ -499,9 +499,8 @@ struct adj_jac_vari : public vari {
     internal::build_y_adj(y_vi_, M_, y_adj);
     auto y_adj_jacs = f_.multiply_adjoint_jacobian(is_var_, y_adj);
 
-    apply(
-        [this](auto&&... args) { this->accumulate_adjoints(args...); },
-        y_adj_jacs);
+    apply([this](auto&&... args) { this->accumulate_adjoints(args...); },
+          y_adj_jacs);
   }
 };
 
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index a2740a11e9c..8639fd4a116 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -16,8 +16,10 @@ namespace stan {
 namespace math {
 namespace internal {
 
-template <typename ReduceFunction, typename ReturnType, typename M, typename... Args>
-struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M, Args...> {
+template <typename ReduceFunction, typename ReturnType, typename M,
+          typename... Args>
+struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
+                       Args...> {
   struct recursive_reducer {
     size_t num_terms_;
     const std::vector<M>& vmapped_;
@@ -26,74 +28,77 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     double sum_;
     Eigen::VectorXd args_adjoints_;
 
-    recursive_reducer(size_t num_terms, const std::vector<M>& vmapped, const Args&... args)
-      : num_terms_(num_terms),
-	vmapped_(vmapped),
-	args_tuple_(args...),
-	sum_(0.0),
-	args_adjoints_(Eigen::VectorXd::Zero(num_terms)) {}
+    recursive_reducer(size_t num_terms, const std::vector<M>& vmapped,
+                      const Args&... args)
+        : num_terms_(num_terms),
+          vmapped_(vmapped),
+          args_tuple_(args...),
+          sum_(0.0),
+          args_adjoints_(Eigen::VectorXd::Zero(num_terms)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-      : num_terms_(other.num_terms_),
-	vmapped_(other.vmapped_),
-	args_tuple_(other.args_tuple_),
-	sum_(other.sum_),
-	args_adjoints_(other.args_adjoints_) {}
+        : num_terms_(other.num_terms_),
+          vmapped_(other.vmapped_),
+          args_tuple_(other.args_tuple_),
+          sum_(other.sum_),
+          args_adjoints_(other.args_adjoints_) {}
 
-    template<typename T>
+    template <typename T>
     T& deep_copy(T& arg) {
       return arg;
     }
 
-    var deep_copy(const var& arg) {
-      return var(arg.val());
-    }
+    var deep_copy(const var& arg) { return var(arg.val()); }
 
     std::vector<var> deep_copy(const std::vector<var>& arg) {
       std::vector<var> copy(arg.size());
-      for(size_t i = 0; i < arg.size(); ++i) {
-	copy[i] = arg[i].val();
+      for (size_t i = 0; i < arg.size(); ++i) {
+        copy[i] = arg[i].val();
       }
       return copy;
     }
 
-    template<int RowType, int ColType>
-    Eigen::Matrix<var, RowType, ColType> deep_copy(const Eigen::Matrix<var, RowType, ColType>& arg) {
+    template <int RowType, int ColType>
+    Eigen::Matrix<var, RowType, ColType> deep_copy(
+        const Eigen::Matrix<var, RowType, ColType>& arg) {
       Eigen::Matrix<var, RowType, ColType> copy(arg.size());
-      for(size_t i = 0; i < arg.size(); ++i) {
-	copy(i) = arg(i).val();
+      for (size_t i = 0; i < arg.size(); ++i) {
+        copy(i) = arg(i).val();
       }
       return copy;
     }
 
-    template<typename... Pargs>
-    void accumulate_adjoints(double *dest, const var& x, const Pargs&... args) {
+    template <typename... Pargs>
+    void accumulate_adjoints(double* dest, const var& x, const Pargs&... args) {
       *dest += x.adj();
       accumulate_adjoints(dest + 1, args...);
     }
 
-    template<typename... Pargs>
-    void accumulate_adjoints(double *dest, const std::vector<var>& x, const Pargs&... args) {
-      for(size_t i = 0; i < x.size(); ++i) {
-	dest[i] += x[i].adj();
+    template <typename... Pargs>
+    void accumulate_adjoints(double* dest, const std::vector<var>& x,
+                             const Pargs&... args) {
+      for (size_t i = 0; i < x.size(); ++i) {
+        dest[i] += x[i].adj();
       }
       accumulate_adjoints(dest + x.size(), args...);
     }
 
-    template<typename... Pargs, int RowType, int ColType>
-    void accumulate_adjoints(double *dest, const Eigen::Matrix<var, RowType, ColType>& x, const Pargs&... args) {
-      for(size_t i = 0; i < x.size(); ++i) {
-	dest[i] += x(i).adj();
+    template <typename... Pargs, int RowType, int ColType>
+    void accumulate_adjoints(double* dest,
+                             const Eigen::Matrix<var, RowType, ColType>& x,
+                             const Pargs&... args) {
+      for (size_t i = 0; i < x.size(); ++i) {
+        dest[i] += x(i).adj();
       }
       accumulate_adjoints(dest + x.size(), args...);
     }
 
-    template<typename R, typename... Pargs>
-    void accumulate_adjoints(double *dest, const R& x, const Pargs&... args) {
+    template <typename R, typename... Pargs>
+    void accumulate_adjoints(double* dest, const R& x, const Pargs&... args) {
       accumulate_adjoints(dest, args...);
     }
 
-    void accumulate_adjoints(double *) {}
+    void accumulate_adjoints(double*) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty())
@@ -111,25 +116,28 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
 
         // create a deep copy of all var's so that these are not
         // linked to any outer AD tree
-	auto args_tuple_local_copy = apply([&](auto&&... args) {
-	    return std::make_tuple(deep_copy(args)...);
-	  }, args_tuple_);
-
-	var sub_sum_v = apply([&](auto&&... args) {
-	    return ReduceFunction()(r.begin(), r.end() - 1, sub_slice,
-				    args...);
-	  },
-	  args_tuple_local_copy);
-
-	sub_sum_v.grad();
-
-	sum_ += sub_sum_v.val();
-
-	// This should accumulate the adjoints from args_tuple_local_copy into
-	//  the memory of args_adjoints_
-	apply([&](auto&&... args) {
-	    accumulate_adjoints(args_adjoints_.data(), args...);
-	  }, args_tuple_local_copy);
+        auto args_tuple_local_copy = apply(
+            [&](auto&&... args) { return std::make_tuple(deep_copy(args)...); },
+            args_tuple_);
+
+        var sub_sum_v = apply(
+            [&](auto&&... args) {
+              return ReduceFunction()(r.begin(), r.end() - 1, sub_slice,
+                                      args...);
+            },
+            args_tuple_local_copy);
+
+        sub_sum_v.grad();
+
+        sum_ += sub_sum_v.val();
+
+        // This should accumulate the adjoints from args_tuple_local_copy into
+        //  the memory of args_adjoints_
+        apply(
+            [&](auto&&... args) {
+              accumulate_adjoints(args_adjoints_.data(), args...);
+            },
+            args_tuple_local_copy);
       } catch (const std::exception& e) {
         recover_memory_nested();
         throw;
@@ -144,19 +152,21 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
   };
 
   template <typename... Pargs, int RowType, int ColType>
-  size_t count_var_impl(size_t count, const Eigen::Matrix<var, RowType, ColType>& x,
-		      const Pargs&... args) const {
+  size_t count_var_impl(size_t count,
+                        const Eigen::Matrix<var, RowType, ColType>& x,
+                        const Pargs&... args) const {
     return count_var_impl(count + x.size(), args...);
   }
 
   template <typename... Pargs>
   size_t count_var_impl(size_t count, const std::vector<var>& x,
-		      const Pargs&... args) const {
+                        const Pargs&... args) const {
     return count_var_impl(count + x.size(), args...);
   }
 
   template <typename... Pargs>
-  size_t count_var_impl(size_t count, const var& x, const Pargs&... args) const {
+  size_t count_var_impl(size_t count, const var& x,
+                        const Pargs&... args) const {
     return count_var_impl(count + 1, args...);
   }
 
@@ -178,37 +188,39 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     return count_var_impl(0, args...);
   }
 
-  template<typename... Pargs>
-  void save_varis(vari **dest, const var& x, const Pargs&... args) const {
+  template <typename... Pargs>
+  void save_varis(vari** dest, const var& x, const Pargs&... args) const {
     *dest = x.vi_;
     save_varis(dest + 1, args...);
   }
 
-  template<typename... Pargs>
-  void save_varis(vari **dest, const std::vector<var>& x, const Pargs&... args) const {
-    for(size_t i = 0; i < x.size(); ++i) {
+  template <typename... Pargs>
+  void save_varis(vari** dest, const std::vector<var>& x,
+                  const Pargs&... args) const {
+    for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x[i].vi_;
     }
     save_varis(dest + x.size(), args...);
   }
 
-  template<typename... Pargs, int RowType, int ColType>
-  void save_varis(vari **dest, const Eigen::Matrix<var, RowType, ColType>& x, const Pargs&... args) const {
-    for(size_t i = 0; i < x.size(); ++i) {
+  template <typename... Pargs, int RowType, int ColType>
+  void save_varis(vari** dest, const Eigen::Matrix<var, RowType, ColType>& x,
+                  const Pargs&... args) const {
+    for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x(i).vi_;
     }
     save_varis(dest + x.size(), args...);
   }
 
-  template<typename R, typename... Pargs>
-  void save_varis(vari **dest, const R& x, const Pargs&... args) const {
+  template <typename R, typename... Pargs>
+  void save_varis(vari** dest, const R& x, const Pargs&... args) const {
     save_varis(dest, args...);
   }
 
-  void save_varis(vari **) const {}
+  void save_varis(vari**) const {}
 
   var operator()(const std::vector<M>& vmapped, std::size_t grainsize,
-		 const Args&... args) const {
+                 const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
     if (num_jobs == 0)
@@ -235,17 +247,16 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
 
     save_varis(varis, args...);
 
-    for(size_t i = 0; i < num_terms; ++i) {
+    for (size_t i = 0; i < num_terms; ++i) {
       partials[i] = worker.args_adjoints_(i);
     }
 
-    return var(new precomputed_gradients_vari(worker.sum_, num_terms,
-                                              varis, partials));
+    return var(new precomputed_gradients_vari(worker.sum_, num_terms, varis,
+                                              partials));
   }
 };
 }  // namespace internal
 
-
 }  // namespace math
 }  // namespace stan
 
diff --git a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
index f08bc2c21ef..b8174967a57 100644
--- a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
@@ -37,7 +37,8 @@ TEST(v3_reduce_sum, value) {
 
   typedef boost::counting_iterator<std::size_t> count_iter;
 
-  double poisson_lpdf = stan::math::reduce_sum<count_lpdf<double>>(data, 5, vlambda_d, idata);
+  double poisson_lpdf
+      = stan::math::reduce_sum<count_lpdf<double>>(data, 5, vlambda_d, idata);
 
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
 
@@ -67,8 +68,8 @@ TEST(v3_reduce_sum, gradient) {
   std::vector<int> idata;
   std::vector<var> vlambda_v(1, lambda_v);
 
-  var poisson_lpdf = stan::math::reduce_sum<count_lpdf<var>>(data, 5,
-								 vlambda_v, idata);
+  var poisson_lpdf
+      = stan::math::reduce_sum<count_lpdf<var>>(data, 5, vlambda_v, idata);
 
   var lambda_ref = lambda_d;
   var poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_ref);

From fbfa9ba8cfbd327efe16a0762e6086a6531d50d3 Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Tue, 14 Jan 2020 23:33:46 -0500
Subject: [PATCH 039/189] Fixup little templating things

---
 stan/math/prim/scal/functor/reduce_sum.hpp |  44 ++---
 stan/math/rev/functor/reduce_sum.hpp       | 182 ++++++++++++---------
 2 files changed, 123 insertions(+), 103 deletions(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index 2cbf4ea898e..0369064fe97 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -19,12 +19,14 @@ namespace math {
 
 namespace internal {
 
-template <typename ReduceFunction, typename Enable, typename ReturnType, typename M, typename... Args>
+template <typename ReduceFunction, typename Enable, typename ReturnType,
+          typename M, typename... Args>
 struct reduce_sum_impl {};
 
-
-template <typename ReduceFunction, typename ReturnType, typename M, typename... Args>
-struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>, ReturnType, M, Args...> {
+template <typename ReduceFunction, typename ReturnType, typename M,
+          typename... Args>
+struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
+                       ReturnType, M, Args...> {
   struct recursive_reducer {
     using vmapped_t = std::vector<M>;
     std::tuple<const Args&...> args_tuple_;
@@ -32,18 +34,16 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>, ReturnT
     double sum_;
 
     recursive_reducer(const vmapped_t& vmapped, const Args&... args)
-      : vmapped_(vmapped),
-	args_tuple_(args...),
-	sum_(0.0) {}
+        : vmapped_(vmapped), args_tuple_(args...), sum_(0.0) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-      : vmapped_(other.vmapped_),
-	args_tuple_(other.args_tuple_),
-	sum_(other.sum_) {}
+        : vmapped_(other.vmapped_),
+          args_tuple_(other.args_tuple_),
+          sum_(other.sum_) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty()) {
-	return;
+        return;
       }
 
       auto start = vmapped_.begin();
@@ -53,18 +53,18 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>, ReturnT
 
       const vmapped_t sub_slice(start, end);
 
-      sum_ += apply([&](auto&&... args) {
-	  return ReduceFunction()(r.begin(), r.end() - 1, sub_slice, args...);
-	}, args_tuple_);
+      sum_ += apply(
+          [&](auto&&... args) {
+            return ReduceFunction()(r.begin(), r.end() - 1, sub_slice, args...);
+          },
+          args_tuple_);
     }
 
-    void join(const recursive_reducer& child) {
-      sum_ += child.sum_;
-    }
+    void join(const recursive_reducer& child) { sum_ += child.sum_; }
   };
 
   double operator()(const std::vector<M>& vmapped, std::size_t grainsize,
-	       const Args&... args) const {
+                    const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
     if (num_jobs == 0)
@@ -94,11 +94,11 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>, ReturnT
  * the functor must be default constructible without any arguments.
  */
 template <typename ReduceFunction, typename M, typename... Args>
-constexpr auto reduce_sum(const std::vector<M>& vmapped,
-			    std::size_t grainsize, const Args&... args) {
+constexpr auto reduce_sum(const std::vector<M>& vmapped, std::size_t grainsize,
+                          const Args&... args) {
   using return_type = return_type_t<Args...>;
-  return internal::reduce_sum_impl<ReduceFunction, void, return_type, M, Args...>()
-    (vmapped, grainsize, args...);
+  return internal::reduce_sum_impl<ReduceFunction, void, return_type, M,
+                                   Args...>()(vmapped, grainsize, args...);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index a2740a11e9c..7125579debe 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -16,8 +16,10 @@ namespace stan {
 namespace math {
 namespace internal {
 
-template <typename ReduceFunction, typename ReturnType, typename M, typename... Args>
-struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M, Args...> {
+template <typename ReduceFunction, typename ReturnType, typename M,
+          typename... Args>
+struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
+                       Args...> {
   struct recursive_reducer {
     size_t num_terms_;
     const std::vector<M>& vmapped_;
@@ -26,74 +28,77 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     double sum_;
     Eigen::VectorXd args_adjoints_;
 
-    recursive_reducer(size_t num_terms, const std::vector<M>& vmapped, const Args&... args)
-      : num_terms_(num_terms),
-	vmapped_(vmapped),
-	args_tuple_(args...),
-	sum_(0.0),
-	args_adjoints_(Eigen::VectorXd::Zero(num_terms)) {}
+    recursive_reducer(size_t num_terms, const std::vector<M>& vmapped,
+                      const Args&... args)
+        : num_terms_(num_terms),
+          vmapped_(vmapped),
+          args_tuple_(args...),
+          sum_(0.0),
+          args_adjoints_(Eigen::VectorXd::Zero(num_terms)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-      : num_terms_(other.num_terms_),
-	vmapped_(other.vmapped_),
-	args_tuple_(other.args_tuple_),
-	sum_(other.sum_),
-	args_adjoints_(other.args_adjoints_) {}
+        : num_terms_(other.num_terms_),
+          vmapped_(other.vmapped_),
+          args_tuple_(other.args_tuple_),
+          sum_(other.sum_),
+          args_adjoints_(other.args_adjoints_) {}
 
-    template<typename T>
+    template <typename T>
     T& deep_copy(T& arg) {
       return arg;
     }
 
-    var deep_copy(const var& arg) {
-      return var(arg.val());
-    }
+    var deep_copy(const var& arg) { return var(arg.val()); }
 
     std::vector<var> deep_copy(const std::vector<var>& arg) {
       std::vector<var> copy(arg.size());
-      for(size_t i = 0; i < arg.size(); ++i) {
-	copy[i] = arg[i].val();
+      for (size_t i = 0; i < arg.size(); ++i) {
+        copy[i] = arg[i].val();
       }
       return copy;
     }
 
-    template<int RowType, int ColType>
-    Eigen::Matrix<var, RowType, ColType> deep_copy(const Eigen::Matrix<var, RowType, ColType>& arg) {
+    template <int RowType, int ColType>
+    Eigen::Matrix<var, RowType, ColType> deep_copy(
+        const Eigen::Matrix<var, RowType, ColType>& arg) {
       Eigen::Matrix<var, RowType, ColType> copy(arg.size());
-      for(size_t i = 0; i < arg.size(); ++i) {
-	copy(i) = arg(i).val();
+      for (size_t i = 0; i < arg.size(); ++i) {
+        copy(i) = arg(i).val();
       }
       return copy;
     }
 
-    template<typename... Pargs>
-    void accumulate_adjoints(double *dest, const var& x, const Pargs&... args) {
+    template <typename... Pargs>
+    void accumulate_adjoints(double* dest, const var& x, const Pargs&... args) {
       *dest += x.adj();
       accumulate_adjoints(dest + 1, args...);
     }
 
-    template<typename... Pargs>
-    void accumulate_adjoints(double *dest, const std::vector<var>& x, const Pargs&... args) {
-      for(size_t i = 0; i < x.size(); ++i) {
-	dest[i] += x[i].adj();
+    template <typename... Pargs>
+    void accumulate_adjoints(double* dest, const std::vector<var>& x,
+                             const Pargs&... args) {
+      for (size_t i = 0; i < x.size(); ++i) {
+        dest[i] += x[i].adj();
       }
       accumulate_adjoints(dest + x.size(), args...);
     }
 
-    template<typename... Pargs, int RowType, int ColType>
-    void accumulate_adjoints(double *dest, const Eigen::Matrix<var, RowType, ColType>& x, const Pargs&... args) {
-      for(size_t i = 0; i < x.size(); ++i) {
-	dest[i] += x(i).adj();
+    template <typename... Pargs, int RowType, int ColType>
+    void accumulate_adjoints(double* dest,
+                             const Eigen::Matrix<var, RowType, ColType>& x,
+                             const Pargs&... args) {
+      for (size_t i = 0; i < x.size(); ++i) {
+        dest[i] += x(i).adj();
       }
       accumulate_adjoints(dest + x.size(), args...);
     }
 
-    template<typename R, typename... Pargs>
-    void accumulate_adjoints(double *dest, const R& x, const Pargs&... args) {
+    template <typename R, typename... Pargs>
+    void accumulate_adjoints(double* dest, const R& x, const Pargs&... args) {
       accumulate_adjoints(dest, args...);
     }
 
-    void accumulate_adjoints(double *) {}
+    void accumulate_adjoints(double*) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty())
@@ -111,25 +116,28 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
 
         // create a deep copy of all var's so that these are not
         // linked to any outer AD tree
-	auto args_tuple_local_copy = apply([&](auto&&... args) {
-	    return std::make_tuple(deep_copy(args)...);
-	  }, args_tuple_);
-
-	var sub_sum_v = apply([&](auto&&... args) {
-	    return ReduceFunction()(r.begin(), r.end() - 1, sub_slice,
-				    args...);
-	  },
-	  args_tuple_local_copy);
-
-	sub_sum_v.grad();
-
-	sum_ += sub_sum_v.val();
-
-	// This should accumulate the adjoints from args_tuple_local_copy into
-	//  the memory of args_adjoints_
-	apply([&](auto&&... args) {
-	    accumulate_adjoints(args_adjoints_.data(), args...);
-	  }, args_tuple_local_copy);
+        auto args_tuple_local_copy = apply(
+            [&](auto&&... args) { return std::make_tuple(deep_copy(args)...); },
+            args_tuple_);
+
+        var sub_sum_v = apply(
+            [&](auto&&... args) {
+              return ReduceFunction()(r.begin(), r.end() - 1, sub_slice,
+                                      args...);
+            },
+            args_tuple_local_copy);
+
+        sub_sum_v.grad();
+
+        sum_ += sub_sum_v.val();
+
+        // This should accumulate the adjoints from args_tuple_local_copy into
+        //  the memory of args_adjoints_
+        apply(
+            [&](auto&&... args) {
+              accumulate_adjoints(args_adjoints_.data(), args...);
+            },
+            args_tuple_local_copy);
       } catch (const std::exception& e) {
         recover_memory_nested();
         throw;
@@ -143,25 +151,36 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     }
   };
 
-  template <typename... Pargs, int RowType, int ColType>
-  size_t count_var_impl(size_t count, const Eigen::Matrix<var, RowType, ColType>& x,
-		      const Pargs&... args) const {
+  // Fails to compile if type T does not have callable member size()
+  template <typename T>
+  using member_size_t = decltype(std::declval<T>().size());
+
+  // TODO(Steve): add requires for generic containers
+  template <typename Container,
+            require_t<is_detected<Container, member_size_t>>...,
+            require_t<is_var<value_type_t<Container>>>..., typename... Pargs>
+  size_t count_var_impl(size_t count, const Container& x,
+                        const Pargs&... args) const {
     return count_var_impl(count + x.size(), args...);
   }
 
-  template <typename... Pargs>
-  size_t count_var_impl(size_t count, const std::vector<var>& x,
-		      const Pargs&... args) const {
-    return count_var_impl(count + x.size(), args...);
+  template <typename Container,
+            require_t<is_detected<Container, member_size_t>>...,
+            require_t<std::is_arithmetic<value_type_t<Container>>>...,
+            typename... Pargs>
+  size_t count_var_impl(size_t count, const Container& x,
+                        const Pargs&... args) const {
+    return count_var_impl(count, args...);
   }
 
   template <typename... Pargs>
-  size_t count_var_impl(size_t count, const var& x, const Pargs&... args) const {
+  size_t count_var_impl(size_t count, const var& x,
+                        const Pargs&... args) const {
     return count_var_impl(count + 1, args...);
   }
 
-  template <typename R, typename... Pargs>
-  size_t count_var_impl(size_t count, const R& x, const Pargs&... args) const {
+  template <typename... Pargs, typename Arith, require_arithmetic_t<Arith>...>
+  size_t count_var_impl(size_t count, Arith& x, const Pargs&... args) const {
     return count_var_impl(count, args...);
   }
 
@@ -178,37 +197,39 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     return count_var_impl(0, args...);
   }
 
-  template<typename... Pargs>
-  void save_varis(vari **dest, const var& x, const Pargs&... args) const {
+  template <typename... Pargs>
+  void save_varis(vari** dest, const var& x, const Pargs&... args) const {
     *dest = x.vi_;
     save_varis(dest + 1, args...);
   }
 
-  template<typename... Pargs>
-  void save_varis(vari **dest, const std::vector<var>& x, const Pargs&... args) const {
-    for(size_t i = 0; i < x.size(); ++i) {
+  template <typename... Pargs>
+  void save_varis(vari** dest, const std::vector<var>& x,
+                  const Pargs&... args) const {
+    for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x[i].vi_;
     }
     save_varis(dest + x.size(), args...);
   }
 
-  template<typename... Pargs, int RowType, int ColType>
-  void save_varis(vari **dest, const Eigen::Matrix<var, RowType, ColType>& x, const Pargs&... args) const {
-    for(size_t i = 0; i < x.size(); ++i) {
+  template <typename... Pargs, int RowType, int ColType>
+  void save_varis(vari** dest, const Eigen::Matrix<var, RowType, ColType>& x,
+                  const Pargs&... args) const {
+    for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x(i).vi_;
     }
     save_varis(dest + x.size(), args...);
   }
 
-  template<typename R, typename... Pargs>
-  void save_varis(vari **dest, const R& x, const Pargs&... args) const {
+  template <typename R, typename... Pargs>
+  void save_varis(vari** dest, const R& x, const Pargs&... args) const {
     save_varis(dest, args...);
   }
 
-  void save_varis(vari **) const {}
+  void save_varis(vari**) const {}
 
   var operator()(const std::vector<M>& vmapped, std::size_t grainsize,
-		 const Args&... args) const {
+                 const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
     if (num_jobs == 0)
@@ -235,17 +256,16 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
 
     save_varis(varis, args...);
 
-    for(size_t i = 0; i < num_terms; ++i) {
+    for (size_t i = 0; i < num_terms; ++i) {
       partials[i] = worker.args_adjoints_(i);
     }
 
-    return var(new precomputed_gradients_vari(worker.sum_, num_terms,
-                                              varis, partials));
+    return var(new precomputed_gradients_vari(worker.sum_, num_terms, varis,
+                                              partials));
   }
 };
 }  // namespace internal
 
-
 }  // namespace math
 }  // namespace stan
 

From 00e5743eab339773ffc9c5c626eeb6010bd92332 Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Tue, 14 Jan 2020 23:50:16 -0500
Subject: [PATCH 040/189] Make accumulate adjoints accept more types

---
 stan/math/rev/functor/reduce_sum.hpp | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 7125579debe..f1568c2a3ef 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -74,18 +74,24 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
       accumulate_adjoints(dest + 1, args...);
     }
 
-    template <typename... Pargs>
-    void accumulate_adjoints(double* dest, const std::vector<var>& x,
+    // Works with anything that has operator[Integral] defined
+    template <typename... Pargs, typename Vec, require_vector_like_vt<is_var, Vec>...>
+    void accumulate_adjoints(double* dest, const Vec& x,
                              const Pargs&... args) {
       for (size_t i = 0; i < x.size(); ++i) {
         dest[i] += x[i].adj();
       }
       accumulate_adjoints(dest + x.size(), args...);
     }
+    // Fails to compile if type T does not have member operator(Integral)
+    template <typename T>
+    using operator_paren_access_t = decltype(std::declval<T>()(int{}));
 
-    template <typename... Pargs, int RowType, int ColType>
+    // Works on anything with a operator()
+    template <typename... Pargs, typename Mat, require_t<is_detected<Mat, operator_paren_access_t>>...,
+    require_t<is_var<value_type_t<Mat>>>...>
     void accumulate_adjoints(double* dest,
-                             const Eigen::Matrix<var, RowType, ColType>& x,
+                             const Mat& x,
                              const Pargs&... args) {
       for (size_t i = 0; i < x.size(); ++i) {
         dest[i] += x(i).adj();
@@ -93,8 +99,9 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
       accumulate_adjoints(dest + x.size(), args...);
     }
 
-    template <typename R, typename... Pargs>
-    void accumulate_adjoints(double* dest, const R& x, const Pargs&... args) {
+    // Anything with a scalar type of Arithmetic gets tossed
+    template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>..., typename... Pargs>
+    void accumulate_adjoints(double* dest, Arith&& x, const Pargs&... args) {
       accumulate_adjoints(dest, args...);
     }
 

From 623ed9e4d6c74863b83343dac00c98cd11d3a585 Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Tue, 14 Jan 2020 23:51:13 -0500
Subject: [PATCH 041/189] Catch arithmetics in count_var_impl

---
 stan/math/rev/functor/reduce_sum.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index f1568c2a3ef..7ab959eeb30 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -186,7 +186,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     return count_var_impl(count + 1, args...);
   }
 
-  template <typename... Pargs, typename Arith, require_arithmetic_t<Arith>...>
+  template <typename... Pargs, typename Arith, require_arithmetic_t<scalar_type_t<Arith>>...>
   size_t count_var_impl(size_t count, Arith& x, const Pargs&... args) const {
     return count_var_impl(count, args...);
   }

From 16db0f2e9e6606102355c8cbd600b1be23a195f1 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Wed, 15 Jan 2020 04:51:50 +0000
Subject: [PATCH 042/189] [Jenkins] auto-formatting by clang-format version
 5.0.0-3~16.04.1 (tags/RELEASE_500/final)

---
 stan/math/rev/functor/reduce_sum.hpp | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 7ab959eeb30..91f055f3548 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -75,9 +75,9 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     }
 
     // Works with anything that has operator[Integral] defined
-    template <typename... Pargs, typename Vec, require_vector_like_vt<is_var, Vec>...>
-    void accumulate_adjoints(double* dest, const Vec& x,
-                             const Pargs&... args) {
+    template <typename... Pargs, typename Vec,
+              require_vector_like_vt<is_var, Vec>...>
+    void accumulate_adjoints(double* dest, const Vec& x, const Pargs&... args) {
       for (size_t i = 0; i < x.size(); ++i) {
         dest[i] += x[i].adj();
       }
@@ -88,11 +88,10 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     using operator_paren_access_t = decltype(std::declval<T>()(int{}));
 
     // Works on anything with a operator()
-    template <typename... Pargs, typename Mat, require_t<is_detected<Mat, operator_paren_access_t>>...,
-    require_t<is_var<value_type_t<Mat>>>...>
-    void accumulate_adjoints(double* dest,
-                             const Mat& x,
-                             const Pargs&... args) {
+    template <typename... Pargs, typename Mat,
+              require_t<is_detected<Mat, operator_paren_access_t>>...,
+              require_t<is_var<value_type_t<Mat>>>...>
+    void accumulate_adjoints(double* dest, const Mat& x, const Pargs&... args) {
       for (size_t i = 0; i < x.size(); ++i) {
         dest[i] += x(i).adj();
       }
@@ -100,7 +99,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     }
 
     // Anything with a scalar type of Arithmetic gets tossed
-    template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>..., typename... Pargs>
+    template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>...,
+              typename... Pargs>
     void accumulate_adjoints(double* dest, Arith&& x, const Pargs&... args) {
       accumulate_adjoints(dest, args...);
     }
@@ -186,7 +186,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     return count_var_impl(count + 1, args...);
   }
 
-  template <typename... Pargs, typename Arith, require_arithmetic_t<scalar_type_t<Arith>>...>
+  template <typename... Pargs, typename Arith,
+            require_arithmetic_t<scalar_type_t<Arith>>...>
   size_t count_var_impl(size_t count, Arith& x, const Pargs&... args) const {
     return count_var_impl(count, args...);
   }

From 9305fb0410a7935d6743956592bc67f72a19a0fd Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Tue, 14 Jan 2020 23:55:28 -0500
Subject: [PATCH 043/189] move operator_paren checker out one scope

---
 stan/math/rev/functor/reduce_sum.hpp | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 7ab959eeb30..b86065e10c5 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -20,6 +20,11 @@ template <typename ReduceFunction, typename ReturnType, typename M,
           typename... Args>
 struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
                        Args...> {
+   // TODO(Steve): Move this somewhere smarter
+   // Fails to compile if type T does not have member operator(Integral)
+   template <typename T>
+   using operator_paren_access_t = decltype(std::declval<T>()(int{}));
+
   struct recursive_reducer {
     size_t num_terms_;
     const std::vector<M>& vmapped_;
@@ -83,9 +88,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
       }
       accumulate_adjoints(dest + x.size(), args...);
     }
-    // Fails to compile if type T does not have member operator(Integral)
-    template <typename T>
-    using operator_paren_access_t = decltype(std::declval<T>()(int{}));
+
 
     // Works on anything with a operator()
     template <typename... Pargs, typename Mat, require_t<is_detected<Mat, operator_paren_access_t>>...,
@@ -210,8 +213,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     save_varis(dest + 1, args...);
   }
 
-  template <typename... Pargs>
-  void save_varis(vari** dest, const std::vector<var>& x,
+  template <typename... Pargs, typename Vec, require_vector_like_vt<is_var, Vec>...>
+  void save_varis(vari** dest, const Vec& x,
                   const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x[i].vi_;
@@ -219,8 +222,9 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     save_varis(dest + x.size(), args...);
   }
 
-  template <typename... Pargs, int RowType, int ColType>
-  void save_varis(vari** dest, const Eigen::Matrix<var, RowType, ColType>& x,
+  template <typename... Pargs, typename Mat, require_t<is_detected<Mat, operator_paren_access_t>>...,
+  require_t<is_var<value_type_t<Mat>>>...>
+  void save_varis(vari** dest, const Mat& x,
                   const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x(i).vi_;

From 430ba3f1e5ed27a1ca198f8a58eccc7f026157fc Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Wed, 15 Jan 2020 04:57:17 +0000
Subject: [PATCH 044/189] [Jenkins] auto-formatting by clang-format version
 5.0.0-3~16.04.1 (tags/RELEASE_500/final)

---
 stan/math/rev/functor/reduce_sum.hpp | 23 +++++++++++------------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 1051f4a466f..57af1e91fac 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -20,10 +20,10 @@ template <typename ReduceFunction, typename ReturnType, typename M,
           typename... Args>
 struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
                        Args...> {
-   // TODO(Steve): Move this somewhere smarter
-   // Fails to compile if type T does not have member operator(Integral)
-   template <typename T>
-   using operator_paren_access_t = decltype(std::declval<T>()(int{}));
+  // TODO(Steve): Move this somewhere smarter
+  // Fails to compile if type T does not have member operator(Integral)
+  template <typename T>
+  using operator_paren_access_t = decltype(std::declval<T>()(int{}));
 
   struct recursive_reducer {
     size_t num_terms_;
@@ -89,7 +89,6 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
       accumulate_adjoints(dest + x.size(), args...);
     }
 
-
     // Works on anything with a operator()
     template <typename... Pargs, typename Mat,
               require_t<is_detected<Mat, operator_paren_access_t>>...,
@@ -214,19 +213,19 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     save_varis(dest + 1, args...);
   }
 
-  template <typename... Pargs, typename Vec, require_vector_like_vt<is_var, Vec>...>
-  void save_varis(vari** dest, const Vec& x,
-                  const Pargs&... args) const {
+  template <typename... Pargs, typename Vec,
+            require_vector_like_vt<is_var, Vec>...>
+  void save_varis(vari** dest, const Vec& x, const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x[i].vi_;
     }
     save_varis(dest + x.size(), args...);
   }
 
-  template <typename... Pargs, typename Mat, require_t<is_detected<Mat, operator_paren_access_t>>...,
-  require_t<is_var<value_type_t<Mat>>>...>
-  void save_varis(vari** dest, const Mat& x,
-                  const Pargs&... args) const {
+  template <typename... Pargs, typename Mat,
+            require_t<is_detected<Mat, operator_paren_access_t>>...,
+            require_t<is_var<value_type_t<Mat>>>...>
+  void save_varis(vari** dest, const Mat& x, const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x(i).vi_;
     }

From 0248bcbb9c4a4f5c9f48cad9cacef6f7b402e93f Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Wed, 15 Jan 2020 01:04:37 -0500
Subject: [PATCH 045/189] add left_fold helper func

---
 stan/math/prim/scal.hpp                    |  1 +
 stan/math/prim/scal/functor/left_fold.hpp  | 40 ++++++++++++++++++++++
 stan/math/prim/scal/functor/reduce_sum.hpp |  1 +
 stan/math/rev/functor/reduce_sum.hpp       | 29 ++++++++--------
 4 files changed, 56 insertions(+), 15 deletions(-)
 create mode 100644 stan/math/prim/scal/functor/left_fold.hpp

diff --git a/stan/math/prim/scal.hpp b/stan/math/prim/scal.hpp
index b31762842ab..b8de98ee26f 100644
--- a/stan/math/prim/scal.hpp
+++ b/stan/math/prim/scal.hpp
@@ -129,6 +129,7 @@
 #include <stan/math/prim/scal/fun/value_of.hpp>
 #include <stan/math/prim/scal/fun/value_of_rec.hpp>
 
+#include <stan/math/prim/scal/functor/left_fold.hpp>
 #include <stan/math/prim/scal/functor/apply.hpp>
 #include <stan/math/prim/scal/functor/reduce_sum.hpp>
 
diff --git a/stan/math/prim/scal/functor/left_fold.hpp b/stan/math/prim/scal/functor/left_fold.hpp
new file mode 100644
index 00000000000..883cd5bd415
--- /dev/null
+++ b/stan/math/prim/scal/functor/left_fold.hpp
@@ -0,0 +1,40 @@
+#ifndef STAN_MATH_PRIM_SCAL_FUNCTOR_LEFT_FOLD_HPP
+#define STAN_MATH_PRIM_SCAL_FUNCTOR_LEFT_FOLD_HPP
+
+#include <functional>
+#include <tuple>
+#include <utility>
+
+namespace stan {
+namespace math {
+
+/**
+ * Performs a left fold on a tuple with a given operation
+ * @tparam index The index in this recursion for accessing tuple elemenTypes
+ * @tparam Op An operation to perform on the tuple elemenTypes
+ * @tparam Types types of tuple elements
+ * @param op operation to perform on individual tuple elements
+ * @param t A tuple to iterate over
+ */
+template <size_t index, class Op, class... Types>
+constexpr auto left_fold(Op op, const std::tuple<Types...>& t) {
+    if (index == sizeof...(Types) - 1) {
+        return std::get<index>(t);
+    } else {
+        return op(std::get<index>(t), left_fold<1 + index>(op, t));
+    }
+}
+
+/**
+ * Sum the elements of a tuple
+ * @tparam Types types of the tuple's elements
+ * @param t tuple whose elements are to be summed
+ */
+template <typename ... Types, require_stan_scalar_t<Types>...>
+constexpr auto sum(const std::tuple<Types...> & t)  {
+  return left_fold<0>(std::plus<>{}, t);
+}
+
+}
+}
+#endif
diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index 0369064fe97..ba33180ec5b 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -30,6 +30,7 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
   struct recursive_reducer {
     using vmapped_t = std::vector<M>;
     std::tuple<const Args&...> args_tuple_;
+    size_t tuple_size_ = sizeof...(Args);
     const vmapped_t& vmapped_;
     double sum_;
 
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 1051f4a466f..b5bae4a562a 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -16,19 +16,21 @@ namespace stan {
 namespace math {
 namespace internal {
 
+
 template <typename ReduceFunction, typename ReturnType, typename M,
           typename... Args>
 struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
                        Args...> {
-   // TODO(Steve): Move this somewhere smarter
-   // Fails to compile if type T does not have member operator(Integral)
-   template <typename T>
-   using operator_paren_access_t = decltype(std::declval<T>()(int{}));
+  // TODO(Steve): Move this somewhere smarter
+  // Fails to compile if type T does not have member operator(Integral)
+  template <typename T>
+  using operator_paren_access_t = decltype(std::declval<T>()(int{}));
 
   struct recursive_reducer {
     size_t num_terms_;
     const std::vector<M>& vmapped_;
     std::tuple<const Args&...> args_tuple_;
+    size_t tuple_size_ = sizeof...(Args);
 
     double sum_;
     Eigen::VectorXd args_adjoints_;
@@ -89,15 +91,12 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
       accumulate_adjoints(dest + x.size(), args...);
     }
 
-
     // Works on anything with a operator()
     template <typename... Pargs, typename Mat,
               require_t<is_detected<Mat, operator_paren_access_t>>...,
               require_t<is_var<value_type_t<Mat>>>...>
     void accumulate_adjoints(double* dest, const Mat& x, const Pargs&... args) {
-      for (size_t i = 0; i < x.size(); ++i) {
-        dest[i] += x(i).adj();
-      }
+      Eigen::Map<matrix_vi>(dest, x.size()) += x.adj();
       accumulate_adjoints(dest + x.size(), args...);
     }
 
@@ -214,19 +213,19 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     save_varis(dest + 1, args...);
   }
 
-  template <typename... Pargs, typename Vec, require_vector_like_vt<is_var, Vec>...>
-  void save_varis(vari** dest, const Vec& x,
-                  const Pargs&... args) const {
+  template <typename... Pargs, typename Vec,
+            require_vector_like_vt<is_var, Vec>...>
+  void save_varis(vari** dest, const Vec& x, const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x[i].vi_;
     }
     save_varis(dest + x.size(), args...);
   }
 
-  template <typename... Pargs, typename Mat, require_t<is_detected<Mat, operator_paren_access_t>>...,
-  require_t<is_var<value_type_t<Mat>>>...>
-  void save_varis(vari** dest, const Mat& x,
-                  const Pargs&... args) const {
+  template <typename... Pargs, typename Mat,
+            require_t<is_detected<Mat, operator_paren_access_t>>...,
+            require_t<is_var<value_type_t<Mat>>>...>
+  void save_varis(vari** dest, const Mat& x, const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x(i).vi_;
     }

From cf8b530ac8f6452deaedf667662a76db39a25df0 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Wed, 15 Jan 2020 06:07:37 +0000
Subject: [PATCH 046/189] [Jenkins] auto-formatting by clang-format version
 5.0.0-3~16.04.1 (tags/RELEASE_500/final)

---
 stan/math/prim/scal/functor/left_fold.hpp | 18 +++++++++---------
 stan/math/rev/functor/reduce_sum.hpp      |  1 -
 2 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/stan/math/prim/scal/functor/left_fold.hpp b/stan/math/prim/scal/functor/left_fold.hpp
index 883cd5bd415..211a781d0c7 100644
--- a/stan/math/prim/scal/functor/left_fold.hpp
+++ b/stan/math/prim/scal/functor/left_fold.hpp
@@ -18,11 +18,11 @@ namespace math {
  */
 template <size_t index, class Op, class... Types>
 constexpr auto left_fold(Op op, const std::tuple<Types...>& t) {
-    if (index == sizeof...(Types) - 1) {
-        return std::get<index>(t);
-    } else {
-        return op(std::get<index>(t), left_fold<1 + index>(op, t));
-    }
+  if (index == sizeof...(Types) - 1) {
+    return std::get<index>(t);
+  } else {
+    return op(std::get<index>(t), left_fold<1 + index>(op, t));
+  }
 }
 
 /**
@@ -30,11 +30,11 @@ constexpr auto left_fold(Op op, const std::tuple<Types...>& t) {
  * @tparam Types types of the tuple's elements
  * @param t tuple whose elements are to be summed
  */
-template <typename ... Types, require_stan_scalar_t<Types>...>
-constexpr auto sum(const std::tuple<Types...> & t)  {
+template <typename... Types, require_stan_scalar_t<Types>...>
+constexpr auto sum(const std::tuple<Types...>& t) {
   return left_fold<0>(std::plus<>{}, t);
 }
 
-}
-}
+}  // namespace math
+}  // namespace stan
 #endif
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index b5bae4a562a..e054a464e80 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -16,7 +16,6 @@ namespace stan {
 namespace math {
 namespace internal {
 
-
 template <typename ReduceFunction, typename ReturnType, typename M,
           typename... Args>
 struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,

From a27047f731e3c16892ce836f10cd179b101240bf Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Wed, 15 Jan 2020 01:25:54 -0500
Subject: [PATCH 047/189] Get slicing tests to pass

---
 stan/math/prim/scal/functor/reduce_sum.hpp                 | 4 ++--
 test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp | 3 +--
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index ba33180ec5b..88585eb4ea0 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -32,7 +32,7 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
     std::tuple<const Args&...> args_tuple_;
     size_t tuple_size_ = sizeof...(Args);
     const vmapped_t& vmapped_;
-    double sum_;
+    return_type_t<M, Args...> sum_;
 
     recursive_reducer(const vmapped_t& vmapped, const Args&... args)
         : vmapped_(vmapped), args_tuple_(args...), sum_(0.0) {}
@@ -64,7 +64,7 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
     void join(const recursive_reducer& child) { sum_ += child.sum_; }
   };
 
-  double operator()(const std::vector<M>& vmapped, std::size_t grainsize,
+  return_type_t<M, Args...> operator()(const std::vector<M>& vmapped, std::size_t grainsize,
                     const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
diff --git a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
index b8174967a57..97548d113eb 100644
--- a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
@@ -245,7 +245,7 @@ TEST(v3_reduce_sum, grouped_gradient) {
   stan::math::recover_memory();
 }
 
-/*
+
 // ********************************
 // slice over the grouping variable which is a var
 // ********************************
@@ -336,4 +336,3 @@ TEST(v3_reduce_sum, slice_group_gradient) {
   ;
   stan::math::recover_memory();
 }
-*/

From 5e3e078d7384ef4d5fd362f9b63bb031287f7f28 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Wed, 15 Jan 2020 06:26:41 +0000
Subject: [PATCH 048/189] [Jenkins] auto-formatting by clang-format version
 5.0.0-3~16.04.1 (tags/RELEASE_500/final)

---
 stan/math/prim/scal/functor/reduce_sum.hpp                 | 5 +++--
 test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp | 2 --
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index 88585eb4ea0..42726084812 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -64,8 +64,9 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
     void join(const recursive_reducer& child) { sum_ += child.sum_; }
   };
 
-  return_type_t<M, Args...> operator()(const std::vector<M>& vmapped, std::size_t grainsize,
-                    const Args&... args) const {
+  return_type_t<M, Args...> operator()(const std::vector<M>& vmapped,
+                                       std::size_t grainsize,
+                                       const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
     if (num_jobs == 0)
diff --git a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
index 97548d113eb..8e3f87ac5f9 100644
--- a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
@@ -245,7 +245,6 @@ TEST(v3_reduce_sum, grouped_gradient) {
   stan::math::recover_memory();
 }
 
-
 // ********************************
 // slice over the grouping variable which is a var
 // ********************************
@@ -283,7 +282,6 @@ TEST(v3_reduce_sum, slice_group_gradient) {
   std::vector<int> gidx(elems);
   std::vector<int> gsidx(groups + 1);
 
-
   for (std::size_t i = 0, k = 0; i != groups; ++i) {
     gsidx[i] = k;
     for (std::size_t j = 0; j != elems_per_group; ++j, ++k) {

From 92fe766872c940ef9629cf853fa10e3ec0800a1c Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sebastian.weber@novartis.com>
Date: Wed, 15 Jan 2020 13:12:06 +0100
Subject: [PATCH 049/189] some fixes, but not yet there

---
 stan/math/prim/scal/functor/reduce_sum.hpp             |  4 ++--
 stan/math/rev/functor/reduce_sum.hpp                   | 10 +++++++---
 .../math/rev/functor/parallel_v3_reduce_sum_test.cpp   | 10 ++++++----
 3 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index 42726084812..276f3016d57 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -40,7 +40,7 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
     recursive_reducer(recursive_reducer& other, tbb::split)
         : vmapped_(other.vmapped_),
           args_tuple_(other.args_tuple_),
-          sum_(other.sum_) {}
+          sum_(0.0) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty()) {
@@ -98,7 +98,7 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
 template <typename ReduceFunction, typename M, typename... Args>
 constexpr auto reduce_sum(const std::vector<M>& vmapped, std::size_t grainsize,
                           const Args&... args) {
-  using return_type = return_type_t<Args...>;
+  using return_type = return_type_t<M, Args...>;
   return internal::reduce_sum_impl<ReduceFunction, void, return_type, M,
                                    Args...>()(vmapped, grainsize, args...);
 }
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index e054a464e80..f028b0f0c27 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -46,7 +46,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
         : num_terms_(other.num_terms_),
           vmapped_(other.vmapped_),
           args_tuple_(other.args_tuple_),
-          sum_(other.sum_),
+          sum_(0.0),
           args_adjoints_(other.args_adjoints_) {}
 
     template <typename T>
@@ -117,13 +117,17 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
       auto end = vmapped_.begin();
       std::advance(end, r.end());
 
-      const std::vector<M> sub_slice(start, end);
-
       try {
         start_nested();
 
         // create a deep copy of all var's so that these are not
         // linked to any outer AD tree
+        std::vector<M> sub_slice;
+        sub_slice.reserve(r.size());
+        for(auto iter = start; iter != end; ++iter) {
+          sub_slice.emplace_back(value_of(*iter));
+        }
+
         auto args_tuple_local_copy = apply(
             [&](auto&&... args) { return std::make_tuple(deep_copy(args)...); },
             args_tuple_);
diff --git a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
index 8e3f87ac5f9..82724af53ec 100644
--- a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
@@ -100,7 +100,7 @@ TEST(v3_reduce_sum, gradient) {
 // ********************************
 // test if nested parallelism works
 // ********************************
-
+/*
 template <typename T>
 struct nesting_count_lpdf {
   nesting_count_lpdf() {}
@@ -161,11 +161,12 @@ TEST(v3_reduce_sum, nesting_gradient) {
 
   stan::math::recover_memory();
 }
-
+*/
 // ********************************
 // basic performance test for a hierarchical model
 // ********************************
 
+/*
 template <typename T>
 struct grouped_count_lpdf {
   grouped_count_lpdf() {}
@@ -244,11 +245,11 @@ TEST(v3_reduce_sum, grouped_gradient) {
 
   stan::math::recover_memory();
 }
-
+*/
 // ********************************
 // slice over the grouping variable which is a var
 // ********************************
-
+/*
 template <typename T>
 struct slice_group_count_lpdf {
   slice_group_count_lpdf() {}
@@ -334,3 +335,4 @@ TEST(v3_reduce_sum, slice_group_gradient) {
   ;
   stan::math::recover_memory();
 }
+*/

From 2d1d57eb11942ef5196a3a5bca71213c26ec824d Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Wed, 15 Jan 2020 12:15:34 +0000
Subject: [PATCH 050/189] [Jenkins] auto-formatting by clang-format version
 5.0.0-3~16.04.1 (tags/RELEASE_500/final)

---
 stan/math/prim/scal/functor/reduce_sum.hpp | 4 +---
 stan/math/rev/functor/reduce_sum.hpp       | 2 +-
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index 276f3016d57..f9a7679f6ed 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -38,9 +38,7 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
         : vmapped_(vmapped), args_tuple_(args...), sum_(0.0) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-        : vmapped_(other.vmapped_),
-          args_tuple_(other.args_tuple_),
-          sum_(0.0) {}
+        : vmapped_(other.vmapped_), args_tuple_(other.args_tuple_), sum_(0.0) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty()) {
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index f028b0f0c27..c0e3aed7565 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -124,7 +124,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
         // linked to any outer AD tree
         std::vector<M> sub_slice;
         sub_slice.reserve(r.size());
-        for(auto iter = start; iter != end; ++iter) {
+        for (auto iter = start; iter != end; ++iter) {
           sub_slice.emplace_back(value_of(*iter));
         }
 

From 906c262be6f5934c4d70a1b0fd8c23fe7e775c20 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Wed, 15 Jan 2020 09:10:01 -0500
Subject: [PATCH 051/189] Merging in changes from pull

---
 stan/math/prim/scal/functor/reduce_sum.hpp |  4 +++-
 stan/math/rev/functor/reduce_sum.hpp       | 23 +++++++++++-----------
 2 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index f9a7679f6ed..691a85a666f 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -38,7 +38,9 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
         : vmapped_(vmapped), args_tuple_(args...), sum_(0.0) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-        : vmapped_(other.vmapped_), args_tuple_(other.args_tuple_), sum_(0.0) {}
+      : vmapped_(other.vmapped_),
+	args_tuple_(other.args_tuple_),
+	sum_(0.0) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty()) {
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index c0e3aed7565..49dd4d02cb9 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -34,20 +34,19 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     double sum_;
     Eigen::VectorXd args_adjoints_;
 
-    recursive_reducer(size_t num_terms, const std::vector<M>& vmapped,
-                      const Args&... args)
-        : num_terms_(num_terms),
-          vmapped_(vmapped),
-          args_tuple_(args...),
-          sum_(0.0),
-          args_adjoints_(Eigen::VectorXd::Zero(num_terms)) {}
+    recursive_reducer(size_t num_terms, const std::vector<M>& vmapped, const Args&... args)
+      : num_terms_(num_terms),
+	vmapped_(vmapped),
+	args_tuple_(args...),
+	sum_(0.0),
+	args_adjoints_(Eigen::VectorXd::Zero(num_terms_)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-        : num_terms_(other.num_terms_),
-          vmapped_(other.vmapped_),
-          args_tuple_(other.args_tuple_),
-          sum_(0.0),
-          args_adjoints_(other.args_adjoints_) {}
+      : num_terms_(other.num_terms_),
+	vmapped_(other.vmapped_),
+	args_tuple_(other.args_tuple_),
+	sum_(0.0),
+	args_adjoints_(Eigen::VectorXd::Zero(num_terms_)) {}
 
     template <typename T>
     T& deep_copy(T& arg) {

From 747c73a76647e635ae8fbd5f7e47ef3f05a1f874 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Wed, 15 Jan 2020 10:57:39 -0500
Subject: [PATCH 052/189] Allow vars in sliced argument, fixed (at least
 temporarily) a couple function signature ambiguities

---
 stan/math/rev/functor/reduce_sum.hpp          | 189 +++++++++---------
 .../functor/parallel_v3_reduce_sum_test.cpp   |  11 +-
 2 files changed, 102 insertions(+), 98 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 49dd4d02cb9..beb582490d9 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -20,13 +20,71 @@ template <typename ReduceFunction, typename ReturnType, typename M,
           typename... Args>
 struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
                        Args...> {
+  template <typename T>
+  static T& deep_copy(T& arg) {
+    return arg;
+  }
+  
+  static var deep_copy(const var& arg) { return var(arg.val()); }
+
+  static std::vector<var> deep_copy(const std::vector<var>& arg) {
+    std::vector<var> copy(arg.size());
+    for (size_t i = 0; i < arg.size(); ++i) {
+      copy[i] = arg[i].val();
+    }
+    return copy;
+  }
+  
+  template <int RowType, int ColType>
+  static Eigen::Matrix<var, RowType, ColType> deep_copy(const Eigen::Matrix<var, RowType, ColType>& arg) {
+    Eigen::Matrix<var, RowType, ColType> copy(arg.size());
+    for (size_t i = 0; i < arg.size(); ++i) {
+      copy(i) = arg(i).val();
+    }
+    return copy;
+  }
+
   // TODO(Steve): Move this somewhere smarter
   // Fails to compile if type T does not have member operator(Integral)
   template <typename T>
   using operator_paren_access_t = decltype(std::declval<T>()(int{}));
 
+  template <typename... Pargs>
+  static double* accumulate_adjoints(double* dest, const var& x, const Pargs&... args) {
+    *dest += x.adj();
+    return accumulate_adjoints(dest + 1, args...);
+  }
+
+  // Works with anything that has operator[Integral] defined
+  template <typename... Pargs, typename Vec,
+	    require_vector_like_vt<is_var, Vec>...>
+  static double* accumulate_adjoints(double* dest, const Vec& x, const Pargs&... args) {
+    for (size_t i = 0; i < x.size(); ++i) {
+      dest[i] += x[i].adj();
+    }
+    return accumulate_adjoints(dest + x.size(), args...);
+  }
+
+  // Works on anything with a operator()
+  template <typename... Pargs, typename Mat,
+	    require_t<is_detected<Mat, operator_paren_access_t>>...,
+	    require_t<is_var<value_type_t<Mat>>>...>
+  static double* accumulate_adjoints(double* dest, const Mat& x, const Pargs&... args) {
+    Eigen::Map<matrix_vi>(dest, x.size()) += x.adj();
+    return accumulate_adjoints(dest + x.size(), args...);
+  }
+
+  // Anything with a scalar type of Arithmetic gets tossed
+  template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>...,
+	    typename... Pargs>
+  static double* accumulate_adjoints(double* dest, Arith&& x, const Pargs&... args) {
+    return accumulate_adjoints(dest, args...);
+  }
+
+  static double* accumulate_adjoints(double* x) { return x; }
+
   struct recursive_reducer {
-    size_t num_terms_;
+    size_t num_shared_terms_;
     const std::vector<M>& vmapped_;
     std::tuple<const Args&...> args_tuple_;
     size_t tuple_size_ = sizeof...(Args);
@@ -34,78 +92,19 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     double sum_;
     Eigen::VectorXd args_adjoints_;
 
-    recursive_reducer(size_t num_terms, const std::vector<M>& vmapped, const Args&... args)
-      : num_terms_(num_terms),
+    recursive_reducer(size_t num_shared_terms, const std::vector<M>& vmapped, const Args&... args)
+      : num_shared_terms_(num_shared_terms),
 	vmapped_(vmapped),
 	args_tuple_(args...),
 	sum_(0.0),
-	args_adjoints_(Eigen::VectorXd::Zero(num_terms_)) {}
+	args_adjoints_(Eigen::VectorXd::Zero(num_shared_terms_)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-      : num_terms_(other.num_terms_),
+      : num_shared_terms_(other.num_shared_terms_),
 	vmapped_(other.vmapped_),
 	args_tuple_(other.args_tuple_),
 	sum_(0.0),
-	args_adjoints_(Eigen::VectorXd::Zero(num_terms_)) {}
-
-    template <typename T>
-    T& deep_copy(T& arg) {
-      return arg;
-    }
-
-    var deep_copy(const var& arg) { return var(arg.val()); }
-
-    std::vector<var> deep_copy(const std::vector<var>& arg) {
-      std::vector<var> copy(arg.size());
-      for (size_t i = 0; i < arg.size(); ++i) {
-        copy[i] = arg[i].val();
-      }
-      return copy;
-    }
-
-    template <int RowType, int ColType>
-    Eigen::Matrix<var, RowType, ColType> deep_copy(
-        const Eigen::Matrix<var, RowType, ColType>& arg) {
-      Eigen::Matrix<var, RowType, ColType> copy(arg.size());
-      for (size_t i = 0; i < arg.size(); ++i) {
-        copy(i) = arg(i).val();
-      }
-      return copy;
-    }
-
-    template <typename... Pargs>
-    void accumulate_adjoints(double* dest, const var& x, const Pargs&... args) {
-      *dest += x.adj();
-      accumulate_adjoints(dest + 1, args...);
-    }
-
-    // Works with anything that has operator[Integral] defined
-    template <typename... Pargs, typename Vec,
-              require_vector_like_vt<is_var, Vec>...>
-    void accumulate_adjoints(double* dest, const Vec& x, const Pargs&... args) {
-      for (size_t i = 0; i < x.size(); ++i) {
-        dest[i] += x[i].adj();
-      }
-      accumulate_adjoints(dest + x.size(), args...);
-    }
-
-    // Works on anything with a operator()
-    template <typename... Pargs, typename Mat,
-              require_t<is_detected<Mat, operator_paren_access_t>>...,
-              require_t<is_var<value_type_t<Mat>>>...>
-    void accumulate_adjoints(double* dest, const Mat& x, const Pargs&... args) {
-      Eigen::Map<matrix_vi>(dest, x.size()) += x.adj();
-      accumulate_adjoints(dest + x.size(), args...);
-    }
-
-    // Anything with a scalar type of Arithmetic gets tossed
-    template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>...,
-              typename... Pargs>
-    void accumulate_adjoints(double* dest, Arith&& x, const Pargs&... args) {
-      accumulate_adjoints(dest, args...);
-    }
-
-    void accumulate_adjoints(double*) {}
+	args_adjoints_(Eigen::VectorXd::Zero(num_shared_terms_)) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty())
@@ -115,28 +114,23 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
       std::advance(start, r.begin());
       auto end = vmapped_.begin();
       std::advance(end, r.end());
+      std::vector<M> sub_slice(start, end);
 
       try {
         start_nested();
 
         // create a deep copy of all var's so that these are not
         // linked to any outer AD tree
-        std::vector<M> sub_slice;
-        sub_slice.reserve(r.size());
-        for (auto iter = start; iter != end; ++iter) {
-          sub_slice.emplace_back(value_of(*iter));
-        }
 
         auto args_tuple_local_copy = apply(
             [&](auto&&... args) { return std::make_tuple(deep_copy(args)...); },
             args_tuple_);
 
-        var sub_sum_v = apply(
-            [&](auto&&... args) {
-              return ReduceFunction()(r.begin(), r.end() - 1, sub_slice,
-                                      args...);
-            },
-            args_tuple_local_copy);
+        var sub_sum_v = apply([&r, &sub_slice](auto&&... args) {
+	    return ReduceFunction()(r.begin(), r.end() - 1, sub_slice,
+				    args...);
+	  },
+	  args_tuple_local_copy);
 
         sub_sum_v.grad();
 
@@ -144,11 +138,10 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
 
         // This should accumulate the adjoints from args_tuple_local_copy into
         //  the memory of args_adjoints_
-        apply(
-            [&](auto&&... args) {
-              accumulate_adjoints(args_adjoints_.data(), args...);
-            },
-            args_tuple_local_copy);
+	apply([&](auto&&... args) {
+	    return accumulate_adjoints(args_adjoints_.data(), args...);
+	  },
+	  args_tuple_local_copy);
       } catch (const std::exception& e) {
         recover_memory_nested();
         throw;
@@ -175,14 +168,16 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     return count_var_impl(count + x.size(), args...);
   }
 
-  template <typename Container,
+  // TODO(Steve): add this back if you want it cause Ben commented it out cause
+  //  it was causing ambiguities
+  /*template <typename Container,
             require_t<is_detected<Container, member_size_t>>...,
             require_t<std::is_arithmetic<value_type_t<Container>>>...,
             typename... Pargs>
   size_t count_var_impl(size_t count, const Container& x,
                         const Pargs&... args) const {
     return count_var_impl(count, args...);
-  }
+    }*/
 
   template <typename... Pargs>
   size_t count_var_impl(size_t count, const var& x,
@@ -234,7 +229,9 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     save_varis(dest + x.size(), args...);
   }
 
-  template <typename R, typename... Pargs>
+  template <typename R,
+	    require_arithmetic_t<scalar_type_t<R>>...,
+	    typename... Pargs>
   void save_varis(vari** dest, const R& x, const Pargs&... args) const {
     save_varis(dest, args...);
   }
@@ -248,9 +245,12 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     if (num_jobs == 0)
       return var(0.0);
 
-    const std::size_t num_terms = count_var(args...);
+    const std::size_t num_sliced_terms = count_var(vmapped);
+    const std::size_t num_shared_terms = count_var(args...);
+
+    auto vmapped_copy = deep_copy(vmapped);
 
-    recursive_reducer worker(num_terms, vmapped, args...);
+    recursive_reducer worker(num_shared_terms, vmapped_copy, args...);
 
 #ifdef STAN_DETERMINISTIC
     tbb::static_partitioner partitioner;
@@ -263,17 +263,22 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
 #endif
 
     vari** varis
-        = ChainableStack::instance_->memalloc_.alloc_array<vari*>(num_terms);
+        = ChainableStack::instance_->memalloc_.alloc_array<vari*>(num_sliced_terms + num_shared_terms);
     double* partials
-        = ChainableStack::instance_->memalloc_.alloc_array<double>(num_terms);
+        = ChainableStack::instance_->memalloc_.alloc_array<double>(num_sliced_terms + num_shared_terms);
 
-    save_varis(varis, args...);
+    save_varis(varis, vmapped);
+    save_varis(varis + num_sliced_terms, args...);
 
-    for (size_t i = 0; i < num_terms; ++i) {
-      partials[i] = worker.args_adjoints_(i);
+    for(size_t i = 0; i < num_sliced_terms; ++i)
+      partials[i] = 0.0;
+    accumulate_adjoints(partials, vmapped_copy);
+    
+    for (size_t i = 0; i < num_shared_terms; ++i) {
+      partials[num_sliced_terms + i] = worker.args_adjoints_(i);
     }
 
-    return var(new precomputed_gradients_vari(worker.sum_, num_terms, varis,
+    return var(new precomputed_gradients_vari(worker.sum_, num_sliced_terms + num_shared_terms, varis,
                                               partials));
   }
 };
diff --git a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
index 82724af53ec..bcc2ad1330e 100644
--- a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
@@ -100,7 +100,6 @@ TEST(v3_reduce_sum, gradient) {
 // ********************************
 // test if nested parallelism works
 // ********************************
-/*
 template <typename T>
 struct nesting_count_lpdf {
   nesting_count_lpdf() {}
@@ -161,12 +160,12 @@ TEST(v3_reduce_sum, nesting_gradient) {
 
   stan::math::recover_memory();
 }
-*/
+
 // ********************************
 // basic performance test for a hierarchical model
 // ********************************
 
-/*
+
 template <typename T>
 struct grouped_count_lpdf {
   grouped_count_lpdf() {}
@@ -245,11 +244,11 @@ TEST(v3_reduce_sum, grouped_gradient) {
 
   stan::math::recover_memory();
 }
-*/
+
 // ********************************
 // slice over the grouping variable which is a var
 // ********************************
-/*
+
 template <typename T>
 struct slice_group_count_lpdf {
   slice_group_count_lpdf() {}
@@ -335,4 +334,4 @@ TEST(v3_reduce_sum, slice_group_gradient) {
   ;
   stan::math::recover_memory();
 }
-*/
+

From 3da42ffb2a800cf92c4559f98e0bd10fcd3fa417 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Wed, 15 Jan 2020 15:59:53 +0000
Subject: [PATCH 053/189] [Jenkins] auto-formatting by clang-format version
 5.0.0-3~16.04.1 (tags/RELEASE_500/final)

---
 stan/math/prim/scal/functor/reduce_sum.hpp    |  4 +-
 stan/math/rev/functor/reduce_sum.hpp          | 91 ++++++++++---------
 .../functor/parallel_v3_reduce_sum_test.cpp   |  2 -
 3 files changed, 50 insertions(+), 47 deletions(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index 691a85a666f..f9a7679f6ed 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -38,9 +38,7 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
         : vmapped_(vmapped), args_tuple_(args...), sum_(0.0) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-      : vmapped_(other.vmapped_),
-	args_tuple_(other.args_tuple_),
-	sum_(0.0) {}
+        : vmapped_(other.vmapped_), args_tuple_(other.args_tuple_), sum_(0.0) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty()) {
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index beb582490d9..6fe8c3db4b8 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -24,7 +24,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
   static T& deep_copy(T& arg) {
     return arg;
   }
-  
+
   static var deep_copy(const var& arg) { return var(arg.val()); }
 
   static std::vector<var> deep_copy(const std::vector<var>& arg) {
@@ -34,9 +34,10 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     }
     return copy;
   }
-  
+
   template <int RowType, int ColType>
-  static Eigen::Matrix<var, RowType, ColType> deep_copy(const Eigen::Matrix<var, RowType, ColType>& arg) {
+  static Eigen::Matrix<var, RowType, ColType> deep_copy(
+      const Eigen::Matrix<var, RowType, ColType>& arg) {
     Eigen::Matrix<var, RowType, ColType> copy(arg.size());
     for (size_t i = 0; i < arg.size(); ++i) {
       copy(i) = arg(i).val();
@@ -50,15 +51,17 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
   using operator_paren_access_t = decltype(std::declval<T>()(int{}));
 
   template <typename... Pargs>
-  static double* accumulate_adjoints(double* dest, const var& x, const Pargs&... args) {
+  static double* accumulate_adjoints(double* dest, const var& x,
+                                     const Pargs&... args) {
     *dest += x.adj();
     return accumulate_adjoints(dest + 1, args...);
   }
 
   // Works with anything that has operator[Integral] defined
   template <typename... Pargs, typename Vec,
-	    require_vector_like_vt<is_var, Vec>...>
-  static double* accumulate_adjoints(double* dest, const Vec& x, const Pargs&... args) {
+            require_vector_like_vt<is_var, Vec>...>
+  static double* accumulate_adjoints(double* dest, const Vec& x,
+                                     const Pargs&... args) {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] += x[i].adj();
     }
@@ -67,17 +70,19 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
 
   // Works on anything with a operator()
   template <typename... Pargs, typename Mat,
-	    require_t<is_detected<Mat, operator_paren_access_t>>...,
-	    require_t<is_var<value_type_t<Mat>>>...>
-  static double* accumulate_adjoints(double* dest, const Mat& x, const Pargs&... args) {
+            require_t<is_detected<Mat, operator_paren_access_t>>...,
+            require_t<is_var<value_type_t<Mat>>>...>
+  static double* accumulate_adjoints(double* dest, const Mat& x,
+                                     const Pargs&... args) {
     Eigen::Map<matrix_vi>(dest, x.size()) += x.adj();
     return accumulate_adjoints(dest + x.size(), args...);
   }
 
   // Anything with a scalar type of Arithmetic gets tossed
   template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>...,
-	    typename... Pargs>
-  static double* accumulate_adjoints(double* dest, Arith&& x, const Pargs&... args) {
+            typename... Pargs>
+  static double* accumulate_adjoints(double* dest, Arith&& x,
+                                     const Pargs&... args) {
     return accumulate_adjoints(dest, args...);
   }
 
@@ -92,19 +97,20 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     double sum_;
     Eigen::VectorXd args_adjoints_;
 
-    recursive_reducer(size_t num_shared_terms, const std::vector<M>& vmapped, const Args&... args)
-      : num_shared_terms_(num_shared_terms),
-	vmapped_(vmapped),
-	args_tuple_(args...),
-	sum_(0.0),
-	args_adjoints_(Eigen::VectorXd::Zero(num_shared_terms_)) {}
+    recursive_reducer(size_t num_shared_terms, const std::vector<M>& vmapped,
+                      const Args&... args)
+        : num_shared_terms_(num_shared_terms),
+          vmapped_(vmapped),
+          args_tuple_(args...),
+          sum_(0.0),
+          args_adjoints_(Eigen::VectorXd::Zero(num_shared_terms_)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-      : num_shared_terms_(other.num_shared_terms_),
-	vmapped_(other.vmapped_),
-	args_tuple_(other.args_tuple_),
-	sum_(0.0),
-	args_adjoints_(Eigen::VectorXd::Zero(num_shared_terms_)) {}
+        : num_shared_terms_(other.num_shared_terms_),
+          vmapped_(other.vmapped_),
+          args_tuple_(other.args_tuple_),
+          sum_(0.0),
+          args_adjoints_(Eigen::VectorXd::Zero(num_shared_terms_)) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty())
@@ -126,11 +132,12 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
             [&](auto&&... args) { return std::make_tuple(deep_copy(args)...); },
             args_tuple_);
 
-        var sub_sum_v = apply([&r, &sub_slice](auto&&... args) {
-	    return ReduceFunction()(r.begin(), r.end() - 1, sub_slice,
-				    args...);
-	  },
-	  args_tuple_local_copy);
+        var sub_sum_v = apply(
+            [&r, &sub_slice](auto&&... args) {
+              return ReduceFunction()(r.begin(), r.end() - 1, sub_slice,
+                                      args...);
+            },
+            args_tuple_local_copy);
 
         sub_sum_v.grad();
 
@@ -138,10 +145,11 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
 
         // This should accumulate the adjoints from args_tuple_local_copy into
         //  the memory of args_adjoints_
-	apply([&](auto&&... args) {
-	    return accumulate_adjoints(args_adjoints_.data(), args...);
-	  },
-	  args_tuple_local_copy);
+        apply(
+            [&](auto&&... args) {
+              return accumulate_adjoints(args_adjoints_.data(), args...);
+            },
+            args_tuple_local_copy);
       } catch (const std::exception& e) {
         recover_memory_nested();
         throw;
@@ -229,9 +237,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     save_varis(dest + x.size(), args...);
   }
 
-  template <typename R,
-	    require_arithmetic_t<scalar_type_t<R>>...,
-	    typename... Pargs>
+  template <typename R, require_arithmetic_t<scalar_type_t<R>>...,
+            typename... Pargs>
   void save_varis(vari** dest, const R& x, const Pargs&... args) const {
     save_varis(dest, args...);
   }
@@ -262,24 +269,24 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
 #endif
 
-    vari** varis
-        = ChainableStack::instance_->memalloc_.alloc_array<vari*>(num_sliced_terms + num_shared_terms);
-    double* partials
-        = ChainableStack::instance_->memalloc_.alloc_array<double>(num_sliced_terms + num_shared_terms);
+    vari** varis = ChainableStack::instance_->memalloc_.alloc_array<vari*>(
+        num_sliced_terms + num_shared_terms);
+    double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(
+        num_sliced_terms + num_shared_terms);
 
     save_varis(varis, vmapped);
     save_varis(varis + num_sliced_terms, args...);
 
-    for(size_t i = 0; i < num_sliced_terms; ++i)
+    for (size_t i = 0; i < num_sliced_terms; ++i)
       partials[i] = 0.0;
     accumulate_adjoints(partials, vmapped_copy);
-    
+
     for (size_t i = 0; i < num_shared_terms; ++i) {
       partials[num_sliced_terms + i] = worker.args_adjoints_(i);
     }
 
-    return var(new precomputed_gradients_vari(worker.sum_, num_sliced_terms + num_shared_terms, varis,
-                                              partials));
+    return var(new precomputed_gradients_vari(
+        worker.sum_, num_sliced_terms + num_shared_terms, varis, partials));
   }
 };
 }  // namespace internal
diff --git a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
index bcc2ad1330e..c74a7a7343c 100644
--- a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
@@ -165,7 +165,6 @@ TEST(v3_reduce_sum, nesting_gradient) {
 // basic performance test for a hierarchical model
 // ********************************
 
-
 template <typename T>
 struct grouped_count_lpdf {
   grouped_count_lpdf() {}
@@ -334,4 +333,3 @@ TEST(v3_reduce_sum, slice_group_gradient) {
   ;
   stan::math::recover_memory();
 }
-

From 70001ac05851064edee7d43afabd5ce037754c06 Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Thu, 16 Jan 2020 16:59:19 +0100
Subject: [PATCH 054/189] make things work with proper cleanup

---
 stan/math/rev/functor/reduce_sum.hpp | 55 +++++++++++++++++-----------
 1 file changed, 34 insertions(+), 21 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 6fe8c3db4b8..83692f24196 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -120,13 +120,13 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
       std::advance(start, r.begin());
       auto end = vmapped_.begin();
       std::advance(end, r.end());
-      std::vector<M> sub_slice(start, end);
 
       try {
         start_nested();
 
         // create a deep copy of all var's so that these are not
         // linked to any outer AD tree
+        const std::vector<M> sub_slice(start, end);
 
         auto args_tuple_local_copy = apply(
             [&](auto&&... args) { return std::make_tuple(deep_copy(args)...); },
@@ -255,38 +255,51 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     const std::size_t num_sliced_terms = count_var(vmapped);
     const std::size_t num_shared_terms = count_var(args...);
 
-    auto vmapped_copy = deep_copy(vmapped);
+    vari** varis = ChainableStack::instance_->memalloc_.alloc_array<vari*>(
+        num_sliced_terms + num_shared_terms);
+    double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(
+        num_sliced_terms + num_shared_terms);
+
+    double sum = 0;
+
+    try {
+      start_nested();
+
+      auto vmapped_copy = deep_copy(vmapped);
 
-    recursive_reducer worker(num_shared_terms, vmapped_copy, args...);
+      recursive_reducer worker(num_shared_terms, vmapped_copy, args...);
 
 #ifdef STAN_DETERMINISTIC
-    tbb::static_partitioner partitioner;
-    tbb::parallel_deterministic_reduce(
-        tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker,
-        partitioner);
+      tbb::static_partitioner partitioner;
+      tbb::parallel_deterministic_reduce(
+          tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker,
+          partitioner);
 #else
-    tbb::parallel_reduce(
-        tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
+      tbb::parallel_reduce(
+          tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
 #endif
 
-    vari** varis = ChainableStack::instance_->memalloc_.alloc_array<vari*>(
-        num_sliced_terms + num_shared_terms);
-    double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(
-        num_sliced_terms + num_shared_terms);
+      save_varis(varis, vmapped);
+      save_varis(varis + num_sliced_terms, args...);
 
-    save_varis(varis, vmapped);
-    save_varis(varis + num_sliced_terms, args...);
+      for (size_t i = 0; i < num_sliced_terms; ++i)
+        partials[i] = 0.0;
+      accumulate_adjoints(partials, vmapped_copy);
 
-    for (size_t i = 0; i < num_sliced_terms; ++i)
-      partials[i] = 0.0;
-    accumulate_adjoints(partials, vmapped_copy);
+      for (size_t i = 0; i < num_shared_terms; ++i) {
+        partials[num_sliced_terms + i] = worker.args_adjoints_(i);
+      }
+
+      sum = worker.sum_;
 
-    for (size_t i = 0; i < num_shared_terms; ++i) {
-      partials[num_sliced_terms + i] = worker.args_adjoints_(i);
+    } catch (const std::exception& e) {
+      recover_memory_nested();
+      throw;
     }
+    recover_memory_nested();
 
     return var(new precomputed_gradients_vari(
-        worker.sum_, num_sliced_terms + num_shared_terms, varis, partials));
+        sum, num_sliced_terms + num_shared_terms, varis, partials));
   }
 };
 }  // namespace internal

From be1ff0c2b89d71aed07f16f10865c2042219cf42 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Thu, 16 Jan 2020 16:16:33 -0500
Subject: [PATCH 055/189] Changed how the sliced gradients work again

---
 stan/math/rev/functor/reduce_sum.hpp | 49 ++++++++++++----------------
 1 file changed, 21 insertions(+), 28 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 83692f24196..047b1d5d491 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -21,7 +21,7 @@ template <typename ReduceFunction, typename ReturnType, typename M,
 struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
                        Args...> {
   template <typename T>
-  static T& deep_copy(T& arg) {
+  static const T& deep_copy(const T& arg) {
     return arg;
   }
 
@@ -95,14 +95,17 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     size_t tuple_size_ = sizeof...(Args);
 
     double sum_;
+    double* sliced_partials_;
     Eigen::VectorXd args_adjoints_;
 
-    recursive_reducer(size_t num_shared_terms, const std::vector<M>& vmapped,
+    recursive_reducer(size_t num_shared_terms, double* sliced_partials,
+		      const std::vector<M>& vmapped,
                       const Args&... args)
         : num_shared_terms_(num_shared_terms),
           vmapped_(vmapped),
           args_tuple_(args...),
           sum_(0.0),
+	  sliced_partials_(sliced_partials),
           args_adjoints_(Eigen::VectorXd::Zero(num_shared_terms_)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
@@ -110,31 +113,33 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
           vmapped_(other.vmapped_),
           args_tuple_(other.args_tuple_),
           sum_(0.0),
+	  sliced_partials_(other.sliced_partials_),
           args_adjoints_(Eigen::VectorXd::Zero(num_shared_terms_)) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty())
         return;
 
-      auto start = vmapped_.begin();
-      std::advance(start, r.begin());
-      auto end = vmapped_.begin();
-      std::advance(end, r.end());
+      std::vector<M> sub_slice;
+      sub_slice.reserve(r.end() - r.begin());
+      for(int i = r.begin(); i < r.end(); ++i) {
+	sub_slice.emplace_back(vmapped_[i]);
+      }
 
       try {
         start_nested();
 
         // create a deep copy of all var's so that these are not
         // linked to any outer AD tree
-        const std::vector<M> sub_slice(start, end);
+	auto local_sub_slice = deep_copy(sub_slice);
 
         auto args_tuple_local_copy = apply(
-            [&](auto&&... args) { return std::make_tuple(deep_copy(args)...); },
+	    [&](auto&&... args) { return std::tuple<decltype(deep_copy(args))...>(deep_copy(args)...); },
             args_tuple_);
 
         var sub_sum_v = apply(
-            [&r, &sub_slice](auto&&... args) {
-              return ReduceFunction()(r.begin(), r.end() - 1, sub_slice,
+            [&r, &local_sub_slice](auto&&... args) {
+              return ReduceFunction()(r.begin(), r.end() - 1, local_sub_slice,
                                       args...);
             },
             args_tuple_local_copy);
@@ -143,8 +148,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
 
         sum_ += sub_sum_v.val();
 
-        // This should accumulate the adjoints from args_tuple_local_copy into
-        //  the memory of args_adjoints_
+	accumulate_adjoints(sliced_partials_ + r.begin(), local_sub_slice);
+	
         apply(
             [&](auto&&... args) {
               return accumulate_adjoints(args_adjoints_.data(), args...);
@@ -260,14 +265,12 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(
         num_sliced_terms + num_shared_terms);
 
-    double sum = 0;
-
-    try {
-      start_nested();
+    for(size_t i = 0; i < num_sliced_terms; ++i)
+      partials[i] = 0.0;
 
-      auto vmapped_copy = deep_copy(vmapped);
+    double sum = 0;
 
-      recursive_reducer worker(num_shared_terms, vmapped_copy, args...);
+    recursive_reducer worker(num_shared_terms, partials, vmapped, args...);
 
 #ifdef STAN_DETERMINISTIC
       tbb::static_partitioner partitioner;
@@ -282,22 +285,12 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
       save_varis(varis, vmapped);
       save_varis(varis + num_sliced_terms, args...);
 
-      for (size_t i = 0; i < num_sliced_terms; ++i)
-        partials[i] = 0.0;
-      accumulate_adjoints(partials, vmapped_copy);
-
       for (size_t i = 0; i < num_shared_terms; ++i) {
         partials[num_sliced_terms + i] = worker.args_adjoints_(i);
       }
 
       sum = worker.sum_;
 
-    } catch (const std::exception& e) {
-      recover_memory_nested();
-      throw;
-    }
-    recover_memory_nested();
-
     return var(new precomputed_gradients_vari(
         sum, num_sliced_terms + num_shared_terms, varis, partials));
   }

From 7a6b558a40270c5a6c7e3a0ddb14eb56923d7cf4 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Thu, 16 Jan 2020 16:17:54 -0500
Subject: [PATCH 056/189] [Jenkins] auto-formatting by clang-format version
 5.0.2-svn328729-1~exp1~20180509124008.99 (branches/release_50)

---
 stan/math/rev/functor/reduce_sum.hpp | 48 +++++++++++++++-------------
 1 file changed, 25 insertions(+), 23 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 047b1d5d491..e81ea3587aa 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -99,13 +99,12 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     Eigen::VectorXd args_adjoints_;
 
     recursive_reducer(size_t num_shared_terms, double* sliced_partials,
-		      const std::vector<M>& vmapped,
-                      const Args&... args)
+                      const std::vector<M>& vmapped, const Args&... args)
         : num_shared_terms_(num_shared_terms),
           vmapped_(vmapped),
           args_tuple_(args...),
           sum_(0.0),
-	  sliced_partials_(sliced_partials),
+          sliced_partials_(sliced_partials),
           args_adjoints_(Eigen::VectorXd::Zero(num_shared_terms_)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
@@ -113,7 +112,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
           vmapped_(other.vmapped_),
           args_tuple_(other.args_tuple_),
           sum_(0.0),
-	  sliced_partials_(other.sliced_partials_),
+          sliced_partials_(other.sliced_partials_),
           args_adjoints_(Eigen::VectorXd::Zero(num_shared_terms_)) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
@@ -122,8 +121,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
 
       std::vector<M> sub_slice;
       sub_slice.reserve(r.end() - r.begin());
-      for(int i = r.begin(); i < r.end(); ++i) {
-	sub_slice.emplace_back(vmapped_[i]);
+      for (int i = r.begin(); i < r.end(); ++i) {
+        sub_slice.emplace_back(vmapped_[i]);
       }
 
       try {
@@ -131,10 +130,13 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
 
         // create a deep copy of all var's so that these are not
         // linked to any outer AD tree
-	auto local_sub_slice = deep_copy(sub_slice);
+        auto local_sub_slice = deep_copy(sub_slice);
 
         auto args_tuple_local_copy = apply(
-	    [&](auto&&... args) { return std::tuple<decltype(deep_copy(args))...>(deep_copy(args)...); },
+            [&](auto&&... args) {
+              return std::tuple<decltype(deep_copy(args))...>(
+                  deep_copy(args)...);
+            },
             args_tuple_);
 
         var sub_sum_v = apply(
@@ -148,8 +150,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
 
         sum_ += sub_sum_v.val();
 
-	accumulate_adjoints(sliced_partials_ + r.begin(), local_sub_slice);
-	
+        accumulate_adjoints(sliced_partials_ + r.begin(), local_sub_slice);
+
         apply(
             [&](auto&&... args) {
               return accumulate_adjoints(args_adjoints_.data(), args...);
@@ -265,7 +267,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(
         num_sliced_terms + num_shared_terms);
 
-    for(size_t i = 0; i < num_sliced_terms; ++i)
+    for (size_t i = 0; i < num_sliced_terms; ++i)
       partials[i] = 0.0;
 
     double sum = 0;
@@ -273,23 +275,23 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     recursive_reducer worker(num_shared_terms, partials, vmapped, args...);
 
 #ifdef STAN_DETERMINISTIC
-      tbb::static_partitioner partitioner;
-      tbb::parallel_deterministic_reduce(
-          tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker,
-          partitioner);
+    tbb::static_partitioner partitioner;
+    tbb::parallel_deterministic_reduce(
+        tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker,
+        partitioner);
 #else
-      tbb::parallel_reduce(
-          tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
+    tbb::parallel_reduce(
+        tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
 #endif
 
-      save_varis(varis, vmapped);
-      save_varis(varis + num_sliced_terms, args...);
+    save_varis(varis, vmapped);
+    save_varis(varis + num_sliced_terms, args...);
 
-      for (size_t i = 0; i < num_shared_terms; ++i) {
-        partials[num_sliced_terms + i] = worker.args_adjoints_(i);
-      }
+    for (size_t i = 0; i < num_shared_terms; ++i) {
+      partials[num_sliced_terms + i] = worker.args_adjoints_(i);
+    }
 
-      sum = worker.sum_;
+    sum = worker.sum_;
 
     return var(new precomputed_gradients_vari(
         sum, num_sliced_terms + num_shared_terms, varis, partials));

From 89bad42801b86a3dce75e78d930ef3e82d9c0e32 Mon Sep 17 00:00:00 2001
From: Sebastian Weber <sdw.post@waebers.de>
Date: Thu, 16 Jan 2020 23:18:30 +0100
Subject: [PATCH 057/189] ensure proper cleaning of vars on all child threads

---
 stan/math/rev/functor/reduce_sum.hpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index e81ea3587aa..457c62fd962 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -119,18 +119,18 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
       if (r.empty())
         return;
 
-      std::vector<M> sub_slice;
-      sub_slice.reserve(r.end() - r.begin());
-      for (int i = r.begin(); i < r.end(); ++i) {
-        sub_slice.emplace_back(vmapped_[i]);
-      }
-
       try {
         start_nested();
 
         // create a deep copy of all var's so that these are not
         // linked to any outer AD tree
-        auto local_sub_slice = deep_copy(sub_slice);
+        std::vector<M> local_sub_slice;
+        local_sub_slice.reserve(r.size());
+        for (int i = r.begin(); i < r.end(); ++i) {
+          local_sub_slice.emplace_back(deep_copy(vmapped_[i]));
+        }
+
+        // auto local_sub_slice = deep_copy(sub_slice);
 
         auto args_tuple_local_copy = apply(
             [&](auto&&... args) {

From c1ac292bf3a9ceed4d8e2687840e793cd6619618 Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Fri, 17 Jan 2020 00:28:03 -0500
Subject: [PATCH 058/189] Adds metaprogramming to accept std vectors and eigen
 vectors

---
 stan/math/prim/scal/functor/reduce_sum.hpp    | 20 +++---
 stan/math/rev/functor/reduce_sum.hpp          | 38 +++++-----
 .../functor/parallel_v3_reduce_sum_test.cpp   | 70 +++++++++++++++++--
 3 files changed, 95 insertions(+), 33 deletions(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index f9a7679f6ed..d3b879dbb90 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -20,19 +20,19 @@ namespace math {
 namespace internal {
 
 template <typename ReduceFunction, typename Enable, typename ReturnType,
-          typename M, typename... Args>
+          typename Vec, typename... Args>
 struct reduce_sum_impl {};
 
-template <typename ReduceFunction, typename ReturnType, typename M,
+template <typename ReduceFunction, typename ReturnType, typename Vec,
           typename... Args>
 struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
-                       ReturnType, M, Args...> {
+                       ReturnType, Vec, Args...> {
   struct recursive_reducer {
-    using vmapped_t = std::vector<M>;
+    using vmapped_t = Vec;
     std::tuple<const Args&...> args_tuple_;
     size_t tuple_size_ = sizeof...(Args);
     const vmapped_t& vmapped_;
-    return_type_t<M, Args...> sum_;
+    return_type_t<Vec, Args...> sum_;
 
     recursive_reducer(const vmapped_t& vmapped, const Args&... args)
         : vmapped_(vmapped), args_tuple_(args...), sum_(0.0) {}
@@ -62,7 +62,7 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
     void join(const recursive_reducer& child) { sum_ += child.sum_; }
   };
 
-  return_type_t<M, Args...> operator()(const std::vector<M>& vmapped,
+  return_type_t<Vec, Args...> operator()(const Vec& vmapped,
                                        std::size_t grainsize,
                                        const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
@@ -93,11 +93,11 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
  * that any internal state of the functor is causing trouble. Thus,
  * the functor must be default constructible without any arguments.
  */
-template <typename ReduceFunction, typename M, typename... Args>
-constexpr auto reduce_sum(const std::vector<M>& vmapped, std::size_t grainsize,
+template <typename ReduceFunction, typename Vec, require_vector_like_t<Vec>..., typename... Args>
+constexpr auto reduce_sum(const Vec& vmapped, std::size_t grainsize,
                           const Args&... args) {
-  using return_type = return_type_t<M, Args...>;
-  return internal::reduce_sum_impl<ReduceFunction, void, return_type, M,
+  using return_type = return_type_t<Vec, Args...>;
+  return internal::reduce_sum_impl<ReduceFunction, void, return_type, Vec,
                                    Args...>()(vmapped, grainsize, args...);
 }
 
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 457c62fd962..9ca2e40679b 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -16,9 +16,9 @@ namespace stan {
 namespace math {
 namespace internal {
 
-template <typename ReduceFunction, typename ReturnType, typename M,
+template <typename ReduceFunction, typename ReturnType, typename Vec,
           typename... Args>
-struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
+struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, Vec,
                        Args...> {
   template <typename T>
   static const T& deep_copy(const T& arg) {
@@ -58,9 +58,9 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
   }
 
   // Works with anything that has operator[Integral] defined
-  template <typename... Pargs, typename Vec,
-            require_vector_like_vt<is_var, Vec>...>
-  static double* accumulate_adjoints(double* dest, const Vec& x,
+  template <typename... Pargs, typename VecVar,
+            require_std_vector_vt<is_var, VecVar>...>
+  static double* accumulate_adjoints(double* dest, const VecVar& x,
                                      const Pargs&... args) {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] += x[i].adj();
@@ -70,11 +70,10 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
 
   // Works on anything with a operator()
   template <typename... Pargs, typename Mat,
-            require_t<is_detected<Mat, operator_paren_access_t>>...,
-            require_t<is_var<value_type_t<Mat>>>...>
+            require_eigen_vt<is_var, Mat>...>
   static double* accumulate_adjoints(double* dest, const Mat& x,
                                      const Pargs&... args) {
-    Eigen::Map<matrix_vi>(dest, x.size()) += x.adj();
+    Eigen::Map<Eigen::Matrix<double, -1, 1>>(dest, x.size()) += x.adj().eval();
     return accumulate_adjoints(dest + x.size(), args...);
   }
 
@@ -90,7 +89,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
 
   struct recursive_reducer {
     size_t num_shared_terms_;
-    const std::vector<M>& vmapped_;
+    const Vec& vmapped_;
     std::tuple<const Args&...> args_tuple_;
     size_t tuple_size_ = sizeof...(Args);
 
@@ -99,7 +98,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     Eigen::VectorXd args_adjoints_;
 
     recursive_reducer(size_t num_shared_terms, double* sliced_partials,
-                      const std::vector<M>& vmapped, const Args&... args)
+                      const Vec& vmapped, const Args&... args)
         : num_shared_terms_(num_shared_terms),
           vmapped_(vmapped),
           args_tuple_(args...),
@@ -124,10 +123,12 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
 
         // create a deep copy of all var's so that these are not
         // linked to any outer AD tree
-        std::vector<M> local_sub_slice;
-        local_sub_slice.reserve(r.size());
+        Vec local_sub_slice(r.size());
+        //local_sub_slice.reserve(r.size());
+        int ii = 0;
         for (int i = r.begin(); i < r.end(); ++i) {
-          local_sub_slice.emplace_back(deep_copy(vmapped_[i]));
+          local_sub_slice[ii] = deep_copy(vmapped_[i]);
+          ii++;
         }
 
         // auto local_sub_slice = deep_copy(sub_slice);
@@ -225,9 +226,9 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
     save_varis(dest + 1, args...);
   }
 
-  template <typename... Pargs, typename Vec,
-            require_vector_like_vt<is_var, Vec>...>
-  void save_varis(vari** dest, const Vec& x, const Pargs&... args) const {
+  template <typename... Pargs, typename VecVar,
+            require_std_vector_vt<is_var, VecVar>...>
+  void save_varis(vari** dest, const VecVar& x, const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x[i].vi_;
     }
@@ -235,8 +236,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
   }
 
   template <typename... Pargs, typename Mat,
-            require_t<is_detected<Mat, operator_paren_access_t>>...,
-            require_t<is_var<value_type_t<Mat>>>...>
+            require_eigen_vt<is_var, Mat>...>
   void save_varis(vari** dest, const Mat& x, const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x(i).vi_;
@@ -252,7 +252,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, M,
 
   void save_varis(vari**) const {}
 
-  var operator()(const std::vector<M>& vmapped, std::size_t grainsize,
+  var operator()(const Vec& vmapped, std::size_t grainsize,
                  const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
diff --git a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
index c74a7a7343c..311ba23a084 100644
--- a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
@@ -170,14 +170,15 @@ struct grouped_count_lpdf {
   grouped_count_lpdf() {}
 
   // does the reduction in the sub-slice start to end
+  template <typename VecInt1, typename VecT, typename VecInt2>
   inline T operator()(std::size_t start, std::size_t end,
-                      const std::vector<int>& sub_slice,
-                      const std::vector<T>& lambda,
-                      const std::vector<int>& gidx) const {
+                      const VecInt1& sub_slice,
+                      const VecT& lambda,
+                      const VecInt2& gidx) const {
     const std::size_t num_terms = end - start + 1;
     // std::cout << "sub-slice " << start << " - " << end << "; num_terms = " <<
     // num_terms << "; size = " << sub_slice.size() << std::endl;
-    std::vector<T> lambda_slice(num_terms, 0.0);
+    VecT lambda_slice(num_terms);
     for (std::size_t i = 0; i != num_terms; ++i)
       lambda_slice[i] = lambda[gidx[start + i]];
     return stan::math::poisson_lpmf(sub_slice, lambda_slice);
@@ -244,6 +245,67 @@ TEST(v3_reduce_sum, grouped_gradient) {
   stan::math::recover_memory();
 }
 
+TEST(v3_reduce_sum, grouped_gradient_eigen) {
+  stan::math::init_threadpool_tbb();
+
+  double lambda_d = 10.0;
+  const std::size_t groups = 10;
+  const std::size_t elems_per_group = 1000;
+  const std::size_t elems = groups * elems_per_group;
+  const std::size_t num_iter = 1000;
+
+  Eigen::Matrix<int, -1, 1> data(elems);
+  std::vector<int> gidx(elems);
+
+  for (std::size_t i = 0; i != elems; ++i) {
+    data[i] = i;
+    gidx[i] = i / elems_per_group;
+  }
+
+  using stan::math::var;
+
+  Eigen::Matrix<var, -1, 1> vlambda_v;
+
+  for (std::size_t i = 0; i != groups; ++i)
+    vlambda_v[i] = i + 0.2;
+
+  var lambda_v = vlambda_v[0];
+
+  var poisson_lpdf = stan::math::reduce_sum<grouped_count_lpdf<var>>(
+      data, 5, vlambda_v, gidx);
+
+  std::vector<var> vref_lambda_v;
+  for (std::size_t i = 0; i != elems; ++i) {
+    vref_lambda_v.push_back(vlambda_v[gidx[i]]);
+  }
+  var lambda_ref = vlambda_v[0];
+
+  var poisson_lpdf_ref = stan::math::poisson_lpmf(data, vref_lambda_v);
+
+  EXPECT_FLOAT_EQ(value_of(poisson_lpdf), value_of(poisson_lpdf_ref));
+
+  stan::math::grad(poisson_lpdf_ref.vi_);
+  const double lambda_ref_adj = lambda_ref.adj();
+
+  stan::math::set_zero_all_adjoints();
+  stan::math::grad(poisson_lpdf.vi_);
+  const double lambda_adj = lambda_v.adj();
+
+  EXPECT_FLOAT_EQ(lambda_adj, lambda_ref_adj);
+
+  std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref.val()
+            << std::endl;
+
+  std::cout << "ref gradient wrt to lambda: " << lambda_ref_adj << std::endl;
+
+  std::cout << "value of poisson lpdf : " << poisson_lpdf.val() << std::endl;
+
+  std::cout << "gradient wrt to lambda: " << lambda_adj << std::endl;
+
+  stan::math::recover_memory();
+}
+
+
 // ********************************
 // slice over the grouping variable which is a var
 // ********************************

From 4ea5f1c52dc93b9afe38c5b400695da6395fcf56 Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Fri, 17 Jan 2020 00:28:48 -0500
Subject: [PATCH 059/189] Remove dead code

---
 stan/math/rev/functor/reduce_sum.hpp | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 9ca2e40679b..be37cc60099 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -184,17 +184,6 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, Ve
     return count_var_impl(count + x.size(), args...);
   }
 
-  // TODO(Steve): add this back if you want it cause Ben commented it out cause
-  //  it was causing ambiguities
-  /*template <typename Container,
-            require_t<is_detected<Container, member_size_t>>...,
-            require_t<std::is_arithmetic<value_type_t<Container>>>...,
-            typename... Pargs>
-  size_t count_var_impl(size_t count, const Container& x,
-                        const Pargs&... args) const {
-    return count_var_impl(count, args...);
-    }*/
-
   template <typename... Pargs>
   size_t count_var_impl(size_t count, const var& x,
                         const Pargs&... args) const {

From 6075dccdd6b589365aa682382d4434ed5ab15d1f Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 17 Jan 2020 00:29:36 -0500
Subject: [PATCH 060/189] [Jenkins] auto-formatting by clang-format version
 6.0.0 (tags/google/stable/2017-11-14)

---
 stan/math/prim/scal/functor/reduce_sum.hpp           |  7 ++++---
 stan/math/rev/functor/reduce_sum.hpp                 | 12 +++++-------
 .../math/rev/functor/parallel_v3_reduce_sum_test.cpp |  4 +---
 3 files changed, 10 insertions(+), 13 deletions(-)

diff --git a/stan/math/prim/scal/functor/reduce_sum.hpp b/stan/math/prim/scal/functor/reduce_sum.hpp
index d3b879dbb90..9c4ae495fb0 100644
--- a/stan/math/prim/scal/functor/reduce_sum.hpp
+++ b/stan/math/prim/scal/functor/reduce_sum.hpp
@@ -63,8 +63,8 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
   };
 
   return_type_t<Vec, Args...> operator()(const Vec& vmapped,
-                                       std::size_t grainsize,
-                                       const Args&... args) const {
+                                         std::size_t grainsize,
+                                         const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
     if (num_jobs == 0)
@@ -93,7 +93,8 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
  * that any internal state of the functor is causing trouble. Thus,
  * the functor must be default constructible without any arguments.
  */
-template <typename ReduceFunction, typename Vec, require_vector_like_t<Vec>..., typename... Args>
+template <typename ReduceFunction, typename Vec, require_vector_like_t<Vec>...,
+          typename... Args>
 constexpr auto reduce_sum(const Vec& vmapped, std::size_t grainsize,
                           const Args&... args) {
   using return_type = return_type_t<Vec, Args...>;
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index be37cc60099..9b2b85a68aa 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -18,8 +18,8 @@ namespace internal {
 
 template <typename ReduceFunction, typename ReturnType, typename Vec,
           typename... Args>
-struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, Vec,
-                       Args...> {
+struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
+                       Vec, Args...> {
   template <typename T>
   static const T& deep_copy(const T& arg) {
     return arg;
@@ -69,8 +69,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, Ve
   }
 
   // Works on anything with a operator()
-  template <typename... Pargs, typename Mat,
-            require_eigen_vt<is_var, Mat>...>
+  template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
   static double* accumulate_adjoints(double* dest, const Mat& x,
                                      const Pargs&... args) {
     Eigen::Map<Eigen::Matrix<double, -1, 1>>(dest, x.size()) += x.adj().eval();
@@ -124,7 +123,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, Ve
         // create a deep copy of all var's so that these are not
         // linked to any outer AD tree
         Vec local_sub_slice(r.size());
-        //local_sub_slice.reserve(r.size());
+        // local_sub_slice.reserve(r.size());
         int ii = 0;
         for (int i = r.begin(); i < r.end(); ++i) {
           local_sub_slice[ii] = deep_copy(vmapped_[i]);
@@ -224,8 +223,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, Ve
     save_varis(dest + x.size(), args...);
   }
 
-  template <typename... Pargs, typename Mat,
-            require_eigen_vt<is_var, Mat>...>
+  template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
   void save_varis(vari** dest, const Mat& x, const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x(i).vi_;
diff --git a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
index 311ba23a084..801594ea889 100644
--- a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
@@ -172,8 +172,7 @@ struct grouped_count_lpdf {
   // does the reduction in the sub-slice start to end
   template <typename VecInt1, typename VecT, typename VecInt2>
   inline T operator()(std::size_t start, std::size_t end,
-                      const VecInt1& sub_slice,
-                      const VecT& lambda,
+                      const VecInt1& sub_slice, const VecT& lambda,
                       const VecInt2& gidx) const {
     const std::size_t num_terms = end - start + 1;
     // std::cout << "sub-slice " << start << " - " << end << "; num_terms = " <<
@@ -305,7 +304,6 @@ TEST(v3_reduce_sum, grouped_gradient_eigen) {
   stan::math::recover_memory();
 }
 
-
 // ********************************
 // slice over the grouping variable which is a var
 // ********************************

From af7791ec041952ecc16a04b21cde725050d647ee Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Fri, 17 Jan 2020 00:52:55 -0500
Subject: [PATCH 061/189] idiot slaps keyboard

---
 stan/math/rev/functor/reduce_sum.hpp          | 20 ++++++++++++++++---
 .../functor/parallel_v3_reduce_sum_test.cpp   |  8 +++-----
 2 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index be37cc60099..6fd7a97a277 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -73,7 +73,9 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, Ve
             require_eigen_vt<is_var, Mat>...>
   static double* accumulate_adjoints(double* dest, const Mat& x,
                                      const Pargs&... args) {
-    Eigen::Map<Eigen::Matrix<double, -1, 1>>(dest, x.size()) += x.adj().eval();
+     for (size_t i = 0; i < x.size(); ++i) {
+       dest[i] += x[i].adj();
+     }
     return accumulate_adjoints(dest + x.size(), args...);
   }
 
@@ -184,6 +186,17 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, Ve
     return count_var_impl(count + x.size(), args...);
   }
 
+  // TODO(Steve): add this back if you want it cause Ben commented it out cause
+  //  it was causing ambiguities
+  /*template <typename Container,
+            require_t<is_detected<Container, member_size_t>>...,
+            require_t<std::is_arithmetic<value_type_t<Container>>>...,
+            typename... Pargs>
+  size_t count_var_impl(size_t count, const Container& x,
+                        const Pargs&... args) const {
+    return count_var_impl(count, args...);
+    }*/
+
   template <typename... Pargs>
   size_t count_var_impl(size_t count, const var& x,
                         const Pargs&... args) const {
@@ -216,7 +229,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, Ve
   }
 
   template <typename... Pargs, typename VecVar,
-            require_std_vector_vt<is_var, VecVar>...>
+            require_vector_like_vt<is_var, VecVar>...>
   void save_varis(vari** dest, const VecVar& x, const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x[i].vi_;
@@ -225,7 +238,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType, Ve
   }
 
   template <typename... Pargs, typename Mat,
-            require_eigen_vt<is_var, Mat>...>
+            require_eigen_vt<is_var, Mat>...,
+            require_not_vector_like_t<Mat>...>
   void save_varis(vari** dest, const Mat& x, const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x(i).vi_;
diff --git a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
index 311ba23a084..3e671fec756 100644
--- a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
@@ -181,6 +181,7 @@ struct grouped_count_lpdf {
     VecT lambda_slice(num_terms);
     for (std::size_t i = 0; i != num_terms; ++i)
       lambda_slice[i] = lambda[gidx[start + i]];
+
     return stan::math::poisson_lpmf(sub_slice, lambda_slice);
   }
 };
@@ -219,7 +220,6 @@ TEST(v3_reduce_sum, grouped_gradient) {
     vref_lambda_v.push_back(vlambda_v[gidx[i]]);
   }
   var lambda_ref = vlambda_v[0];
-
   var poisson_lpdf_ref = stan::math::poisson_lpmf(data, vref_lambda_v);
 
   EXPECT_FLOAT_EQ(value_of(poisson_lpdf), value_of(poisson_lpdf_ref));
@@ -261,18 +261,16 @@ TEST(v3_reduce_sum, grouped_gradient_eigen) {
     data[i] = i;
     gidx[i] = i / elems_per_group;
   }
-
   using stan::math::var;
 
-  Eigen::Matrix<var, -1, 1> vlambda_v;
+  Eigen::Matrix<var, -1, 1> vlambda_v(groups);
 
   for (std::size_t i = 0; i != groups; ++i)
     vlambda_v[i] = i + 0.2;
-
   var lambda_v = vlambda_v[0];
 
   var poisson_lpdf = stan::math::reduce_sum<grouped_count_lpdf<var>>(
-      data, 5, vlambda_v, gidx);
+    data, 5, vlambda_v, gidx);
 
   std::vector<var> vref_lambda_v;
   for (std::size_t i = 0; i != elems; ++i) {

From ab1e653060e6070dff497ddfaa79860ebdbabe7b Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 17 Jan 2020 00:55:20 -0500
Subject: [PATCH 062/189] [Jenkins] auto-formatting by clang-format version
 6.0.0 (tags/google/stable/2017-11-14)

---
 stan/math/rev/functor/reduce_sum.hpp                       | 6 +++---
 test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index ee50498e943..d2f5ab3d976 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -72,9 +72,9 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
   static double* accumulate_adjoints(double* dest, const Mat& x,
                                      const Pargs&... args) {
-     for (size_t i = 0; i < x.size(); ++i) {
-       dest[i] += x[i].adj();
-     }
+    for (size_t i = 0; i < x.size(); ++i) {
+      dest[i] += x[i].adj();
+    }
     return accumulate_adjoints(dest + x.size(), args...);
   }
 
diff --git a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
index dafd5c07189..c3104cee033 100644
--- a/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/parallel_v3_reduce_sum_test.cpp
@@ -269,7 +269,7 @@ TEST(v3_reduce_sum, grouped_gradient_eigen) {
   var lambda_v = vlambda_v[0];
 
   var poisson_lpdf = stan::math::reduce_sum<grouped_count_lpdf<var>>(
-    data, 5, vlambda_v, gidx);
+      data, 5, vlambda_v, gidx);
 
   std::vector<var> vref_lambda_v;
   for (std::size_t i = 0; i != elems; ++i) {

From 37b516fa1cbb919a7003c2f3b65912ecb107c1a4 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 17 Jan 2020 12:09:44 -0500
Subject: [PATCH 063/189] [Jenkins] auto-formatting by clang-format version
 6.0.0 (tags/google/stable/2017-11-14)

---
 test/unit/math/prim/functor/reduce_sum_test.cpp | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/test/unit/math/prim/functor/reduce_sum_test.cpp b/test/unit/math/prim/functor/reduce_sum_test.cpp
index a19a29c8e56..eeedd8b1343 100644
--- a/test/unit/math/prim/functor/reduce_sum_test.cpp
+++ b/test/unit/math/prim/functor/reduce_sum_test.cpp
@@ -37,7 +37,8 @@ TEST(v3_reduce_sum, value) {
 
   typedef boost::counting_iterator<std::size_t> count_iter;
 
-  double poisson_lpdf = stan::math::reduce_sum<count_lpdf<double>>(data, 5, vlambda_d, idata);
+  double poisson_lpdf
+      = stan::math::reduce_sum<count_lpdf<double>>(data, 5, vlambda_d, idata);
 
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
 
@@ -48,7 +49,6 @@ TEST(v3_reduce_sum, value) {
   std::cout << "value of poisson lpdf : " << poisson_lpdf << std::endl;
 }
 
-
 // ********************************
 // test if nested parallelism works
 // ********************************
@@ -62,8 +62,7 @@ struct nesting_count_lpdf {
                       const std::vector<int>& sub_slice,
                       const std::vector<T>& lambda,
                       const std::vector<int>& idata) const {
-    return stan::math::reduce_sum<count_lpdf<T>>(sub_slice, 5, lambda,
-                                                 idata);
+    return stan::math::reduce_sum<count_lpdf<T>>(sub_slice, 5, lambda, idata);
   }
 };
 
@@ -83,8 +82,8 @@ TEST(v3_reduce_sum, nesting_value) {
 
   typedef boost::counting_iterator<std::size_t> count_iter;
 
-  double poisson_lpdf = stan::math::reduce_sum<count_lpdf<double>>(
-      data, 5, vlambda_d, idata);
+  double poisson_lpdf
+      = stan::math::reduce_sum<count_lpdf<double>>(data, 5, vlambda_d, idata);
 
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
 

From b76cd8ca98cf9563f0b7233ddbd45e863dae076b Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Fri, 17 Jan 2020 15:37:03 -0500
Subject: [PATCH 064/189] Added tests for reduce_sum

---
 stan/math/prim/functor/reduce_sum.hpp         |  15 +-
 stan/math/rev/functor/reduce_sum.hpp          |   6 +-
 .../unit/math/mix/functor/reduce_sum_test.cpp | 161 +++++++++++++++
 .../math/prim/functor/reduce_sum_test.cpp     | 193 +++++++++++++++++-
 4 files changed, 362 insertions(+), 13 deletions(-)
 create mode 100644 test/unit/math/mix/functor/reduce_sum_test.cpp

diff --git a/stan/math/prim/functor/reduce_sum.hpp b/stan/math/prim/functor/reduce_sum.hpp
index b88b97f42f8..1ce7445a917 100644
--- a/stan/math/prim/functor/reduce_sum.hpp
+++ b/stan/math/prim/functor/reduce_sum.hpp
@@ -21,7 +21,18 @@ namespace internal {
 
 template <typename ReduceFunction, typename Enable, typename ReturnType,
           typename Vec, typename... Args>
-struct reduce_sum_impl {};
+struct reduce_sum_impl {
+  return_type_t<Vec, Args...> operator()(const Vec& vmapped,
+                                         std::size_t grainsize,
+                                         const Args&... args) const {
+    const std::size_t num_jobs = vmapped.size();
+
+    if (num_jobs == 0)
+      return 0.0;
+
+    return ReduceFunction()(0, vmapped.size() - 1, vmapped, args...);
+  }
+};
 
 template <typename ReduceFunction, typename ReturnType, typename Vec,
           typename... Args>
@@ -95,7 +106,7 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
  */
 template <typename ReduceFunction, typename Vec, require_vector_like_t<Vec>...,
           typename... Args>
-constexpr auto reduce_sum(const Vec& vmapped, std::size_t grainsize,
+auto reduce_sum(const Vec& vmapped, std::size_t grainsize,
                           const Args&... args) {
   using return_type = return_type_t<Vec, Args...>;
   return internal::reduce_sum_impl<ReduceFunction, void, return_type, Vec,
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index d2f5ab3d976..96ae9a5294a 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -38,7 +38,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   template <int RowType, int ColType>
   static Eigen::Matrix<var, RowType, ColType> deep_copy(
       const Eigen::Matrix<var, RowType, ColType>& arg) {
-    Eigen::Matrix<var, RowType, ColType> copy(arg.size());
+    Eigen::Matrix<var, RowType, ColType> copy(arg.rows(), arg.cols());
     for (size_t i = 0; i < arg.size(); ++i) {
       copy(i) = arg(i).val();
     }
@@ -73,7 +73,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   static double* accumulate_adjoints(double* dest, const Mat& x,
                                      const Pargs&... args) {
     for (size_t i = 0; i < x.size(); ++i) {
-      dest[i] += x[i].adj();
+      dest[i] += x(i).adj();
     }
     return accumulate_adjoints(dest + x.size(), args...);
   }
@@ -281,7 +281,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     }
 
     sum = worker.sum_;
-
+    
     return var(new precomputed_gradients_vari(
         sum, num_sliced_terms + num_shared_terms, varis, partials));
   }
diff --git a/test/unit/math/mix/functor/reduce_sum_test.cpp b/test/unit/math/mix/functor/reduce_sum_test.cpp
new file mode 100644
index 00000000000..b692d50de8a
--- /dev/null
+++ b/test/unit/math/mix/functor/reduce_sum_test.cpp
@@ -0,0 +1,161 @@
+#include <test/unit/math/test_ad.hpp>
+#include <limits>
+
+template <typename T>
+T sum_(const T& arg) {
+  return arg;
+}
+
+template <typename T>
+auto sum_(const std::vector<T>& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename T, int RowType, int ColType>
+auto sum_(const Eigen::Matrix<T, RowType, ColType>& arg) {
+  return stan::math::sum(arg);
+}
+
+struct sum_lpdf {
+  template <typename T, typename... Args>
+  inline auto operator()(std::size_t start, std::size_t end,
+			 const std::vector<T>& sub_slice,
+			 const Args&... args) const {
+    using return_type = stan::return_type_t<T, Args...>;
+
+    return stan::math::sum(sub_slice) +
+      sub_slice.size() * stan::math::sum(std::vector<return_type>{ return_type(sum_(args))... });
+  }
+};
+
+TEST(MathMix_reduce_sum, double_slice) {
+  auto f = [](const auto& data) {
+    return stan::math::reduce_sum<sum_lpdf>(data, 0);
+  };
+  
+  std::vector<double> data(5, 10.0);
+
+  stan::test::expect_ad(f, data);
+}
+
+auto fi = [](const auto&... args) {
+  return stan::math::reduce_sum<sum_lpdf>(std::vector<int>(2, 10.0), 0, args...);
+};
+
+auto fd = [](const auto& data, const auto&... args) {
+  return stan::math::reduce_sum<sum_lpdf>(data, 0, args...);
+};
+
+TEST(MathMix_reduce_sum, int_arg) {
+ std::vector<double> data(2, 1.0);
+  int arg = 5.0;
+
+  stan::test::expect_ad([&](const auto& data) {
+      return fd(data, arg);
+    }, data);
+}
+
+TEST(MathMix_reduce_sum, double_arg) {
+  std::vector<double> data(2, 10.0);
+  double arg = 5.0;
+
+  stan::test::expect_ad(fi, arg);
+  stan::test::expect_ad(fd, data, arg);
+}
+
+TEST(MathMix_reduce_sum, std_vector_int_arg) {
+  std::vector<double> data(2, 10.0);
+  std::vector<int> arg(2, 10);
+
+  stan::test::expect_ad([&](const auto& data) {
+      return fd(data, arg);
+    }, data);
+}
+
+TEST(MathMix_reduce_sum, std_vector_double_arg) {
+  std::vector<double> data(2, 10.0);
+  std::vector<double> arg(2, 10.0);
+
+  stan::test::expect_ad(fi, arg);
+  stan::test::expect_ad(fd, data, arg);
+}
+
+TEST(MathMix_reduce_sum, eigen_vector_arg) {
+  std::vector<double> data(2, 10.0);
+  Eigen::VectorXd arg = Eigen::VectorXd::Ones(2);
+
+  stan::test::expect_ad(fi, arg);
+  stan::test::expect_ad(fd, data, arg);
+}
+
+TEST(MathMix_reduce_sum, eigen_row_vector_arg) {
+  std::vector<double> data(2, 10.0);
+  Eigen::RowVectorXd arg = Eigen::RowVectorXd::Ones(2);
+
+  stan::test::expect_ad(fi, arg);
+  stan::test::expect_ad(fd, data, arg);
+}
+
+TEST(MathMix_reduce_sum, eigen_matrix_arg) {
+  std::vector<double> data(2, 10.0);
+  Eigen::MatrixXd arg = Eigen::MatrixXd::Ones(2, 2);
+
+  stan::test::expect_ad(fi, arg);
+  stan::test::expect_ad(fd, data, arg);
+}
+
+TEST(MathMix_reduce_sum, eigen_three_args1) {
+  Eigen::VectorXd arg1 = Eigen::VectorXd::Ones(2);
+  Eigen::RowVectorXd arg2 = Eigen::RowVectorXd::Ones(2);
+  Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
+
+  stan::test::expect_ad(fi, arg1, arg2, arg3);
+}
+
+TEST(MathMix_reduce_sum, eigen_three_args2) {
+  double arg1 = 1.0;
+  std::vector<double> arg2(2, 1.0);
+  Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
+
+  stan::test::expect_ad(fi, arg1, arg2, arg3);
+}
+
+TEST(MathMix_reduce_sum, eigen_three_args_with_ints1) {
+  Eigen::VectorXd arg1 = Eigen::VectorXd::Ones(2);
+  Eigen::RowVectorXd arg2 = Eigen::RowVectorXd::Ones(2);
+  Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
+
+  stan::test::expect_ad([&](const auto& arg1, const auto& arg2, const auto& arg3) {
+      return fi(1, arg1, std::vector<int>{1, 2, 3}, arg2, 3, arg3);
+    }, arg1, arg2, arg3);
+}
+
+TEST(MathMix_reduce_sum, eigen_three_args_with_ints2) {
+  double arg1 = 1.0;
+  std::vector<double> arg2(2, 1.0);
+  Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
+
+  stan::test::expect_ad([&](const auto& arg1, const auto& arg2, const auto& arg3) {
+      return fi(1, arg1, std::vector<int>{1, 2, 3}, arg2, 3, arg3);
+    }, arg1, arg2, arg3);
+}
+
+TEST(MathMix_reduce_sum, eigen_three_args_with_doubles1) {
+  Eigen::VectorXd arg1 = Eigen::VectorXd::Ones(2);
+  Eigen::RowVectorXd arg2 = Eigen::RowVectorXd::Ones(2);
+  Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
+
+  stan::test::expect_ad([&](const auto& arg1, const auto& arg2, const auto& arg3) {
+      return fi(std::vector<double>{1.0, 2.0, 3.0}, arg1, 3.0, arg2, std::vector<double>{1.0, 2.0, 3.0}, arg3);
+    }, arg1, arg2, arg3);
+}
+
+TEST(MathMix_reduce_sum, eigen_three_args_with_doubles2) {
+  double arg1 = 1.0;
+  std::vector<double> arg2(2, 1.0);
+  Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
+
+  stan::test::expect_ad([&](const auto& arg1, const auto& arg2, const auto& arg3) {
+      return fi(std::vector<double>{1.0, 2.0, 3.0}, arg1, 3.0, arg2, std::vector<double>{1.0, 2.0, 3.0}, arg3);
+    }, arg1, arg2, arg3);
+}
diff --git a/test/unit/math/prim/functor/reduce_sum_test.cpp b/test/unit/math/prim/functor/reduce_sum_test.cpp
index eeedd8b1343..9625393d468 100644
--- a/test/unit/math/prim/functor/reduce_sum_test.cpp
+++ b/test/unit/math/prim/functor/reduce_sum_test.cpp
@@ -21,7 +21,7 @@ struct count_lpdf {
   }
 };
 
-TEST(v3_reduce_sum, value) {
+TEST(StanMath_reduce_sum, value) {
   stan::math::init_threadpool_tbb();
 
   double lambda_d = 10.0;
@@ -43,10 +43,6 @@ TEST(v3_reduce_sum, value) {
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
 
   EXPECT_FLOAT_EQ(poisson_lpdf, poisson_lpdf_ref);
-
-  std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref << std::endl;
-
-  std::cout << "value of poisson lpdf : " << poisson_lpdf << std::endl;
 }
 
 // ********************************
@@ -66,7 +62,7 @@ struct nesting_count_lpdf {
   }
 };
 
-TEST(v3_reduce_sum, nesting_value) {
+TEST(StanMath_reduce_sum, nesting_value) {
   stan::math::init_threadpool_tbb();
 
   double lambda_d = 10.0;
@@ -88,8 +84,189 @@ TEST(v3_reduce_sum, nesting_value) {
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
 
   EXPECT_FLOAT_EQ(poisson_lpdf, poisson_lpdf_ref);
+}
+
+struct int_slice_lpdf {
+  inline auto operator()(std::size_t start, std::size_t end,
+                      const std::vector<int>& sub_slice) const {
+    return stan::math::sum(sub_slice);
+  }
+};
+
+struct double_slice_lpdf {
+  inline auto operator()(std::size_t start, std::size_t end,
+                      const std::vector<double>& sub_slice) const {
+    return stan::math::sum(sub_slice);
+  }
+};
+
+TEST(StanMath_reduce_sum, int_slice) {
+  stan::math::init_threadpool_tbb();
+
+  std::vector<int> data(5, 10);
+  
+  EXPECT_EQ(50, stan::math::reduce_sum<int_slice_lpdf>(data, 0));
+}
+
+TEST(StanMath_reduce_sum, double_slice) {
+  stan::math::init_threadpool_tbb();
+
+  std::vector<double> data(5, 10.0);
+  
+  EXPECT_DOUBLE_EQ(50.0, stan::math::reduce_sum<double_slice_lpdf>(data, 0));
+}
+
+struct int_arg_lpdf {
+  inline auto operator()(std::size_t start, std::size_t end,
+			 const std::vector<double>& sub_slice,
+			 const int& arg) const {
+    return stan::math::sum(sub_slice) + sub_slice.size() * arg;
+  }
+};
+
+struct double_arg_lpdf {
+  inline auto operator()(std::size_t start, std::size_t end,
+			 const std::vector<double>& sub_slice,
+			 const double& arg) const {
+    return stan::math::sum(sub_slice) + sub_slice.size() * arg;
+  }
+};
+
+struct std_vector_int_arg_lpdf {
+  inline auto operator()(std::size_t start, std::size_t end,
+			 const std::vector<double>& sub_slice,
+			 const std::vector<int>& arg) const {
+    return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
+  }
+};
+
+struct std_vector_double_arg_lpdf {
+  inline auto operator()(std::size_t start, std::size_t end,
+			 const std::vector<double>& sub_slice,
+			 const std::vector<double>& arg) const {
+    return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
+  }
+};
+
+struct eigen_vector_arg_lpdf {
+  inline auto operator()(std::size_t start, std::size_t end,
+			 const std::vector<double>& sub_slice,
+			 const Eigen::VectorXd& arg) const {
+    return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
+  }
+};
+
+struct eigen_row_vector_arg_lpdf {
+  inline auto operator()(std::size_t start, std::size_t end,
+			 const std::vector<double>& sub_slice,
+			 const Eigen::RowVectorXd& arg) const {
+    return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
+  }
+};
 
-  std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref << std::endl;
+struct eigen_matrix_arg_lpdf {
+  inline auto operator()(std::size_t start, std::size_t end,
+			 const std::vector<double>& sub_slice,
+			 const Eigen::MatrixXd& arg) const {
+    return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
+  }
+};
+
+TEST(StanMath_reduce_sum, int_arg) {
+  stan::math::init_threadpool_tbb();
+
+  std::vector<double> data(5, 10.0);
+  int arg = 5;
+  
+  EXPECT_DOUBLE_EQ(5 * (10 + 5), stan::math::reduce_sum<int_arg_lpdf>(data, 0, arg));
+}
+
+TEST(StanMath_reduce_sum, double_arg) {
+  stan::math::init_threadpool_tbb();
+
+  std::vector<double> data(5, 10.0);
+  double arg = 5.0;
+  
+  EXPECT_DOUBLE_EQ(5 * (10.0 + 5.0), stan::math::reduce_sum<double_arg_lpdf>(data, 0, arg));
+}
+
+TEST(StanMath_reduce_sum, std_vector_int_arg) {
+  stan::math::init_threadpool_tbb();
+
+  std::vector<double> data(5, 10.0);
+  std::vector<int> arg(5, 10);
+  
+  EXPECT_DOUBLE_EQ(5 * (10 + 5 * 10), stan::math::reduce_sum<std_vector_int_arg_lpdf>(data, 0, arg));
+}
+
+TEST(StanMath_reduce_sum, std_vector_double_arg) {
+  stan::math::init_threadpool_tbb();
+
+  std::vector<double> data(5, 10.0);
+  std::vector<double> arg(5, 10.0);
+  
+  EXPECT_DOUBLE_EQ(5 * (10 + 5 * 10), stan::math::reduce_sum<std_vector_double_arg_lpdf>(data, 0, arg));
+}
+
+TEST(StanMath_reduce_sum, eigen_vector_arg) {
+  stan::math::init_threadpool_tbb();
+
+  std::vector<double> data(5, 10.0);
+  Eigen::VectorXd arg = Eigen::VectorXd::Ones(5);
+  
+  EXPECT_DOUBLE_EQ(5 * (10 + 5), stan::math::reduce_sum<eigen_vector_arg_lpdf>(data, 0, arg));
+}
+
+TEST(StanMath_reduce_sum, eigen_row_vector_arg) {
+  stan::math::init_threadpool_tbb();
+
+  std::vector<double> data(5, 10.0);
+  Eigen::RowVectorXd arg = Eigen::RowVectorXd::Ones(5);
+  
+  EXPECT_DOUBLE_EQ(5 * (10 + 5), stan::math::reduce_sum<eigen_row_vector_arg_lpdf>(data, 0, arg));
+}
+
+TEST(StanMath_reduce_sum, eigen_matrix_arg) {
+  stan::math::init_threadpool_tbb();
+
+  std::vector<double> data(5, 10.0);
+  Eigen::MatrixXd arg = Eigen::MatrixXd::Ones(5, 5);
+  
+  EXPECT_DOUBLE_EQ(5 * (10 + 5 * 5), stan::math::reduce_sum<eigen_matrix_arg_lpdf>(data, 0, arg));
+}
+
+struct sum_lpdf {
+  inline auto operator()(std::size_t start, std::size_t end,
+			 const std::vector<double>& sub_slice,
+			 const int& arg1,
+			 const double& arg2,
+			 const std::vector<int>& arg3,
+			 const std::vector<double>& arg4,
+			 const Eigen::VectorXd& arg5,
+			 const Eigen::RowVectorXd& arg6,
+			 const Eigen::MatrixXd& arg7) const {
+    return stan::math::sum(sub_slice) +
+      sub_slice.size() * (arg1 + arg2 +
+			  stan::math::sum(arg3) + stan::math::sum(arg4) +
+			  stan::math::sum(arg5) + stan::math::sum(arg6) +
+			  stan::math::sum(arg7));
+  }
+};
+
+TEST(StanMath_reduce_sum, sum) {
+  stan::math::init_threadpool_tbb();
 
-  std::cout << "value of poisson lpdf : " << poisson_lpdf << std::endl;
+  std::vector<double> data(5, 1.0);
+  int arg1 = 1;
+  double arg2 = 1.0;
+  std::vector<int> arg3(5, 1);
+  std::vector<double> arg4(5, 1.0);
+  Eigen::VectorXd arg5 = Eigen::VectorXd::Ones(5);
+  Eigen::RowVectorXd arg6 = Eigen::RowVectorXd::Ones(5);
+  Eigen::MatrixXd arg7 = Eigen::MatrixXd::Ones(5, 5);
+  
+  EXPECT_DOUBLE_EQ(5 + 5 * (1 + 1 + 5 + 5 + 5 + 5 + 25),
+		   stan::math::reduce_sum<sum_lpdf>(data, 0, arg1, arg2,
+						    arg3, arg4, arg5, arg6,
+						    arg7));
 }

From 6b93f93409757b8936161842c9852261443e7e69 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 17 Jan 2020 15:39:40 -0500
Subject: [PATCH 065/189] [Jenkins] auto-formatting by clang-format version
 5.0.2-svn328729-1~exp1~20180509124008.99 (branches/release_50)

---
 stan/math/prim/functor/reduce_sum.hpp         |   2 +-
 stan/math/rev/functor/reduce_sum.hpp          |   2 +-
 .../unit/math/mix/functor/reduce_sum_test.cpp |  59 +++++-----
 .../math/prim/functor/reduce_sum_test.cpp     | 105 ++++++++++--------
 4 files changed, 92 insertions(+), 76 deletions(-)

diff --git a/stan/math/prim/functor/reduce_sum.hpp b/stan/math/prim/functor/reduce_sum.hpp
index 1ce7445a917..ff80a03d25c 100644
--- a/stan/math/prim/functor/reduce_sum.hpp
+++ b/stan/math/prim/functor/reduce_sum.hpp
@@ -107,7 +107,7 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
 template <typename ReduceFunction, typename Vec, require_vector_like_t<Vec>...,
           typename... Args>
 auto reduce_sum(const Vec& vmapped, std::size_t grainsize,
-                          const Args&... args) {
+                const Args&... args) {
   using return_type = return_type_t<Vec, Args...>;
   return internal::reduce_sum_impl<ReduceFunction, void, return_type, Vec,
                                    Args...>()(vmapped, grainsize, args...);
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 96ae9a5294a..81a942f7986 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -281,7 +281,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     }
 
     sum = worker.sum_;
-    
+
     return var(new precomputed_gradients_vari(
         sum, num_sliced_terms + num_shared_terms, varis, partials));
   }
diff --git a/test/unit/math/mix/functor/reduce_sum_test.cpp b/test/unit/math/mix/functor/reduce_sum_test.cpp
index b692d50de8a..e3c865f2da2 100644
--- a/test/unit/math/mix/functor/reduce_sum_test.cpp
+++ b/test/unit/math/mix/functor/reduce_sum_test.cpp
@@ -19,12 +19,14 @@ auto sum_(const Eigen::Matrix<T, RowType, ColType>& arg) {
 struct sum_lpdf {
   template <typename T, typename... Args>
   inline auto operator()(std::size_t start, std::size_t end,
-			 const std::vector<T>& sub_slice,
-			 const Args&... args) const {
+                         const std::vector<T>& sub_slice,
+                         const Args&... args) const {
     using return_type = stan::return_type_t<T, Args...>;
 
-    return stan::math::sum(sub_slice) +
-      sub_slice.size() * stan::math::sum(std::vector<return_type>{ return_type(sum_(args))... });
+    return stan::math::sum(sub_slice)
+           + sub_slice.size()
+                 * stan::math::sum(
+                       std::vector<return_type>{return_type(sum_(args))...});
   }
 };
 
@@ -32,14 +34,15 @@ TEST(MathMix_reduce_sum, double_slice) {
   auto f = [](const auto& data) {
     return stan::math::reduce_sum<sum_lpdf>(data, 0);
   };
-  
+
   std::vector<double> data(5, 10.0);
 
   stan::test::expect_ad(f, data);
 }
 
 auto fi = [](const auto&... args) {
-  return stan::math::reduce_sum<sum_lpdf>(std::vector<int>(2, 10.0), 0, args...);
+  return stan::math::reduce_sum<sum_lpdf>(std::vector<int>(2, 10.0), 0,
+                                          args...);
 };
 
 auto fd = [](const auto& data, const auto&... args) {
@@ -47,12 +50,10 @@ auto fd = [](const auto& data, const auto&... args) {
 };
 
 TEST(MathMix_reduce_sum, int_arg) {
- std::vector<double> data(2, 1.0);
+  std::vector<double> data(2, 1.0);
   int arg = 5.0;
 
-  stan::test::expect_ad([&](const auto& data) {
-      return fd(data, arg);
-    }, data);
+  stan::test::expect_ad([&](const auto& data) { return fd(data, arg); }, data);
 }
 
 TEST(MathMix_reduce_sum, double_arg) {
@@ -67,9 +68,7 @@ TEST(MathMix_reduce_sum, std_vector_int_arg) {
   std::vector<double> data(2, 10.0);
   std::vector<int> arg(2, 10);
 
-  stan::test::expect_ad([&](const auto& data) {
-      return fd(data, arg);
-    }, data);
+  stan::test::expect_ad([&](const auto& data) { return fd(data, arg); }, data);
 }
 
 TEST(MathMix_reduce_sum, std_vector_double_arg) {
@@ -125,9 +124,11 @@ TEST(MathMix_reduce_sum, eigen_three_args_with_ints1) {
   Eigen::RowVectorXd arg2 = Eigen::RowVectorXd::Ones(2);
   Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
 
-  stan::test::expect_ad([&](const auto& arg1, const auto& arg2, const auto& arg3) {
-      return fi(1, arg1, std::vector<int>{1, 2, 3}, arg2, 3, arg3);
-    }, arg1, arg2, arg3);
+  stan::test::expect_ad(
+      [&](const auto& arg1, const auto& arg2, const auto& arg3) {
+        return fi(1, arg1, std::vector<int>{1, 2, 3}, arg2, 3, arg3);
+      },
+      arg1, arg2, arg3);
 }
 
 TEST(MathMix_reduce_sum, eigen_three_args_with_ints2) {
@@ -135,9 +136,11 @@ TEST(MathMix_reduce_sum, eigen_three_args_with_ints2) {
   std::vector<double> arg2(2, 1.0);
   Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
 
-  stan::test::expect_ad([&](const auto& arg1, const auto& arg2, const auto& arg3) {
-      return fi(1, arg1, std::vector<int>{1, 2, 3}, arg2, 3, arg3);
-    }, arg1, arg2, arg3);
+  stan::test::expect_ad(
+      [&](const auto& arg1, const auto& arg2, const auto& arg3) {
+        return fi(1, arg1, std::vector<int>{1, 2, 3}, arg2, 3, arg3);
+      },
+      arg1, arg2, arg3);
 }
 
 TEST(MathMix_reduce_sum, eigen_three_args_with_doubles1) {
@@ -145,9 +148,12 @@ TEST(MathMix_reduce_sum, eigen_three_args_with_doubles1) {
   Eigen::RowVectorXd arg2 = Eigen::RowVectorXd::Ones(2);
   Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
 
-  stan::test::expect_ad([&](const auto& arg1, const auto& arg2, const auto& arg3) {
-      return fi(std::vector<double>{1.0, 2.0, 3.0}, arg1, 3.0, arg2, std::vector<double>{1.0, 2.0, 3.0}, arg3);
-    }, arg1, arg2, arg3);
+  stan::test::expect_ad(
+      [&](const auto& arg1, const auto& arg2, const auto& arg3) {
+        return fi(std::vector<double>{1.0, 2.0, 3.0}, arg1, 3.0, arg2,
+                  std::vector<double>{1.0, 2.0, 3.0}, arg3);
+      },
+      arg1, arg2, arg3);
 }
 
 TEST(MathMix_reduce_sum, eigen_three_args_with_doubles2) {
@@ -155,7 +161,10 @@ TEST(MathMix_reduce_sum, eigen_three_args_with_doubles2) {
   std::vector<double> arg2(2, 1.0);
   Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
 
-  stan::test::expect_ad([&](const auto& arg1, const auto& arg2, const auto& arg3) {
-      return fi(std::vector<double>{1.0, 2.0, 3.0}, arg1, 3.0, arg2, std::vector<double>{1.0, 2.0, 3.0}, arg3);
-    }, arg1, arg2, arg3);
+  stan::test::expect_ad(
+      [&](const auto& arg1, const auto& arg2, const auto& arg3) {
+        return fi(std::vector<double>{1.0, 2.0, 3.0}, arg1, 3.0, arg2,
+                  std::vector<double>{1.0, 2.0, 3.0}, arg3);
+      },
+      arg1, arg2, arg3);
 }
diff --git a/test/unit/math/prim/functor/reduce_sum_test.cpp b/test/unit/math/prim/functor/reduce_sum_test.cpp
index 9625393d468..84b9ea5e0d9 100644
--- a/test/unit/math/prim/functor/reduce_sum_test.cpp
+++ b/test/unit/math/prim/functor/reduce_sum_test.cpp
@@ -88,14 +88,14 @@ TEST(StanMath_reduce_sum, nesting_value) {
 
 struct int_slice_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
-                      const std::vector<int>& sub_slice) const {
+                         const std::vector<int>& sub_slice) const {
     return stan::math::sum(sub_slice);
   }
 };
 
 struct double_slice_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
-                      const std::vector<double>& sub_slice) const {
+                         const std::vector<double>& sub_slice) const {
     return stan::math::sum(sub_slice);
   }
 };
@@ -104,7 +104,7 @@ TEST(StanMath_reduce_sum, int_slice) {
   stan::math::init_threadpool_tbb();
 
   std::vector<int> data(5, 10);
-  
+
   EXPECT_EQ(50, stan::math::reduce_sum<int_slice_lpdf>(data, 0));
 }
 
@@ -112,62 +112,62 @@ TEST(StanMath_reduce_sum, double_slice) {
   stan::math::init_threadpool_tbb();
 
   std::vector<double> data(5, 10.0);
-  
+
   EXPECT_DOUBLE_EQ(50.0, stan::math::reduce_sum<double_slice_lpdf>(data, 0));
 }
 
 struct int_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
-			 const std::vector<double>& sub_slice,
-			 const int& arg) const {
+                         const std::vector<double>& sub_slice,
+                         const int& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * arg;
   }
 };
 
 struct double_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
-			 const std::vector<double>& sub_slice,
-			 const double& arg) const {
+                         const std::vector<double>& sub_slice,
+                         const double& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * arg;
   }
 };
 
 struct std_vector_int_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
-			 const std::vector<double>& sub_slice,
-			 const std::vector<int>& arg) const {
+                         const std::vector<double>& sub_slice,
+                         const std::vector<int>& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
   }
 };
 
 struct std_vector_double_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
-			 const std::vector<double>& sub_slice,
-			 const std::vector<double>& arg) const {
+                         const std::vector<double>& sub_slice,
+                         const std::vector<double>& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
   }
 };
 
 struct eigen_vector_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
-			 const std::vector<double>& sub_slice,
-			 const Eigen::VectorXd& arg) const {
+                         const std::vector<double>& sub_slice,
+                         const Eigen::VectorXd& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
   }
 };
 
 struct eigen_row_vector_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
-			 const std::vector<double>& sub_slice,
-			 const Eigen::RowVectorXd& arg) const {
+                         const std::vector<double>& sub_slice,
+                         const Eigen::RowVectorXd& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
   }
 };
 
 struct eigen_matrix_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
-			 const std::vector<double>& sub_slice,
-			 const Eigen::MatrixXd& arg) const {
+                         const std::vector<double>& sub_slice,
+                         const Eigen::MatrixXd& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
   }
 };
@@ -177,8 +177,9 @@ TEST(StanMath_reduce_sum, int_arg) {
 
   std::vector<double> data(5, 10.0);
   int arg = 5;
-  
-  EXPECT_DOUBLE_EQ(5 * (10 + 5), stan::math::reduce_sum<int_arg_lpdf>(data, 0, arg));
+
+  EXPECT_DOUBLE_EQ(5 * (10 + 5),
+                   stan::math::reduce_sum<int_arg_lpdf>(data, 0, arg));
 }
 
 TEST(StanMath_reduce_sum, double_arg) {
@@ -186,8 +187,9 @@ TEST(StanMath_reduce_sum, double_arg) {
 
   std::vector<double> data(5, 10.0);
   double arg = 5.0;
-  
-  EXPECT_DOUBLE_EQ(5 * (10.0 + 5.0), stan::math::reduce_sum<double_arg_lpdf>(data, 0, arg));
+
+  EXPECT_DOUBLE_EQ(5 * (10.0 + 5.0),
+                   stan::math::reduce_sum<double_arg_lpdf>(data, 0, arg));
 }
 
 TEST(StanMath_reduce_sum, std_vector_int_arg) {
@@ -195,8 +197,10 @@ TEST(StanMath_reduce_sum, std_vector_int_arg) {
 
   std::vector<double> data(5, 10.0);
   std::vector<int> arg(5, 10);
-  
-  EXPECT_DOUBLE_EQ(5 * (10 + 5 * 10), stan::math::reduce_sum<std_vector_int_arg_lpdf>(data, 0, arg));
+
+  EXPECT_DOUBLE_EQ(
+      5 * (10 + 5 * 10),
+      stan::math::reduce_sum<std_vector_int_arg_lpdf>(data, 0, arg));
 }
 
 TEST(StanMath_reduce_sum, std_vector_double_arg) {
@@ -204,8 +208,10 @@ TEST(StanMath_reduce_sum, std_vector_double_arg) {
 
   std::vector<double> data(5, 10.0);
   std::vector<double> arg(5, 10.0);
-  
-  EXPECT_DOUBLE_EQ(5 * (10 + 5 * 10), stan::math::reduce_sum<std_vector_double_arg_lpdf>(data, 0, arg));
+
+  EXPECT_DOUBLE_EQ(
+      5 * (10 + 5 * 10),
+      stan::math::reduce_sum<std_vector_double_arg_lpdf>(data, 0, arg));
 }
 
 TEST(StanMath_reduce_sum, eigen_vector_arg) {
@@ -213,8 +219,9 @@ TEST(StanMath_reduce_sum, eigen_vector_arg) {
 
   std::vector<double> data(5, 10.0);
   Eigen::VectorXd arg = Eigen::VectorXd::Ones(5);
-  
-  EXPECT_DOUBLE_EQ(5 * (10 + 5), stan::math::reduce_sum<eigen_vector_arg_lpdf>(data, 0, arg));
+
+  EXPECT_DOUBLE_EQ(5 * (10 + 5),
+                   stan::math::reduce_sum<eigen_vector_arg_lpdf>(data, 0, arg));
 }
 
 TEST(StanMath_reduce_sum, eigen_row_vector_arg) {
@@ -222,8 +229,10 @@ TEST(StanMath_reduce_sum, eigen_row_vector_arg) {
 
   std::vector<double> data(5, 10.0);
   Eigen::RowVectorXd arg = Eigen::RowVectorXd::Ones(5);
-  
-  EXPECT_DOUBLE_EQ(5 * (10 + 5), stan::math::reduce_sum<eigen_row_vector_arg_lpdf>(data, 0, arg));
+
+  EXPECT_DOUBLE_EQ(
+      5 * (10 + 5),
+      stan::math::reduce_sum<eigen_row_vector_arg_lpdf>(data, 0, arg));
 }
 
 TEST(StanMath_reduce_sum, eigen_matrix_arg) {
@@ -231,25 +240,24 @@ TEST(StanMath_reduce_sum, eigen_matrix_arg) {
 
   std::vector<double> data(5, 10.0);
   Eigen::MatrixXd arg = Eigen::MatrixXd::Ones(5, 5);
-  
-  EXPECT_DOUBLE_EQ(5 * (10 + 5 * 5), stan::math::reduce_sum<eigen_matrix_arg_lpdf>(data, 0, arg));
+
+  EXPECT_DOUBLE_EQ(5 * (10 + 5 * 5),
+                   stan::math::reduce_sum<eigen_matrix_arg_lpdf>(data, 0, arg));
 }
 
 struct sum_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
-			 const std::vector<double>& sub_slice,
-			 const int& arg1,
-			 const double& arg2,
-			 const std::vector<int>& arg3,
-			 const std::vector<double>& arg4,
-			 const Eigen::VectorXd& arg5,
-			 const Eigen::RowVectorXd& arg6,
-			 const Eigen::MatrixXd& arg7) const {
-    return stan::math::sum(sub_slice) +
-      sub_slice.size() * (arg1 + arg2 +
-			  stan::math::sum(arg3) + stan::math::sum(arg4) +
-			  stan::math::sum(arg5) + stan::math::sum(arg6) +
-			  stan::math::sum(arg7));
+                         const std::vector<double>& sub_slice, const int& arg1,
+                         const double& arg2, const std::vector<int>& arg3,
+                         const std::vector<double>& arg4,
+                         const Eigen::VectorXd& arg5,
+                         const Eigen::RowVectorXd& arg6,
+                         const Eigen::MatrixXd& arg7) const {
+    return stan::math::sum(sub_slice)
+           + sub_slice.size()
+                 * (arg1 + arg2 + stan::math::sum(arg3) + stan::math::sum(arg4)
+                    + stan::math::sum(arg5) + stan::math::sum(arg6)
+                    + stan::math::sum(arg7));
   }
 };
 
@@ -264,9 +272,8 @@ TEST(StanMath_reduce_sum, sum) {
   Eigen::VectorXd arg5 = Eigen::VectorXd::Ones(5);
   Eigen::RowVectorXd arg6 = Eigen::RowVectorXd::Ones(5);
   Eigen::MatrixXd arg7 = Eigen::MatrixXd::Ones(5, 5);
-  
+
   EXPECT_DOUBLE_EQ(5 + 5 * (1 + 1 + 5 + 5 + 5 + 5 + 25),
-		   stan::math::reduce_sum<sum_lpdf>(data, 0, arg1, arg2,
-						    arg3, arg4, arg5, arg6,
-						    arg7));
+                   stan::math::reduce_sum<sum_lpdf>(data, 0, arg1, arg2, arg3,
+                                                    arg4, arg5, arg6, arg7));
 }

From e804157acf726bb3410a8de736b6c4b64da70aa9 Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Fri, 17 Jan 2020 16:05:12 -0500
Subject: [PATCH 066/189] Fix cpplint errors

---
 stan/math/prim/functor/reduce_sum.hpp          | 1 +
 stan/math/rev/functor/reduce_sum.hpp           | 4 +++-
 test/unit/math/mix/functor/reduce_sum_test.cpp | 1 +
 test/unit/math/rev/functor/reduce_sum_test.cpp | 7 +++----
 4 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/stan/math/prim/functor/reduce_sum.hpp b/stan/math/prim/functor/reduce_sum.hpp
index ff80a03d25c..93bb3f42b0c 100644
--- a/stan/math/prim/functor/reduce_sum.hpp
+++ b/stan/math/prim/functor/reduce_sum.hpp
@@ -12,6 +12,7 @@
 
 #include <iostream>
 #include <iterator>
+#include <tuple>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 81a942f7986..e7696a9c8a9 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -10,6 +10,8 @@
 
 #include <iostream>
 #include <iterator>
+#include <tuple>
+#include <algorithm>
 #include <vector>
 
 namespace stan {
@@ -239,7 +241,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     save_varis(dest, args...);
   }
 
-  void save_varis(vari**) const {}
+  void save_varis(vari** /* v */) const {}
 
   var operator()(const Vec& vmapped, std::size_t grainsize,
                  const Args&... args) const {
diff --git a/test/unit/math/mix/functor/reduce_sum_test.cpp b/test/unit/math/mix/functor/reduce_sum_test.cpp
index e3c865f2da2..f78a00efce8 100644
--- a/test/unit/math/mix/functor/reduce_sum_test.cpp
+++ b/test/unit/math/mix/functor/reduce_sum_test.cpp
@@ -1,5 +1,6 @@
 #include <test/unit/math/test_ad.hpp>
 #include <limits>
+#include <vector>
 
 template <typename T>
 T sum_(const T& arg) {
diff --git a/test/unit/math/rev/functor/reduce_sum_test.cpp b/test/unit/math/rev/functor/reduce_sum_test.cpp
index c3104cee033..ddafa3d75ea 100644
--- a/test/unit/math/rev/functor/reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/reduce_sum_test.cpp
@@ -381,13 +381,12 @@ TEST(v3_reduce_sum, slice_group_gradient) {
 
   std::cout << "ref value of poisson lpdf : " << poisson_lpdf_ref.val()
             << std::endl;
-  ;
+
   std::cout << "ref gradient wrt to lambda: " << lambda_ref_adj << std::endl;
-  ;
+
 
   std::cout << "value of poisson lpdf : " << poisson_lpdf.val() << std::endl;
-  ;
+
   std::cout << "gradient wrt to lambda: " << lambda_adj << std::endl;
-  ;
   stan::math::recover_memory();
 }

From 66acef6180d893900681ffc4975dc666f47b7387 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 17 Jan 2020 16:05:57 -0500
Subject: [PATCH 067/189] [Jenkins] auto-formatting by clang-format version
 5.0.2-svn328729-1~exp1~20180509124008.99 (branches/release_50)

---
 test/unit/math/rev/functor/reduce_sum_test.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/unit/math/rev/functor/reduce_sum_test.cpp b/test/unit/math/rev/functor/reduce_sum_test.cpp
index ddafa3d75ea..ee405744534 100644
--- a/test/unit/math/rev/functor/reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/reduce_sum_test.cpp
@@ -384,7 +384,6 @@ TEST(v3_reduce_sum, slice_group_gradient) {
 
   std::cout << "ref gradient wrt to lambda: " << lambda_ref_adj << std::endl;
 
-
   std::cout << "value of poisson lpdf : " << poisson_lpdf.val() << std::endl;
 
   std::cout << "gradient wrt to lambda: " << lambda_adj << std::endl;

From 906d7b08613f78f3411ae54188edea698d42f834 Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Fri, 17 Jan 2020 16:19:33 -0500
Subject: [PATCH 068/189] Fix headers

---
 stan/math/prim/functor/reduce_sum.hpp          | 4 ++--
 stan/math/rev/functor/reduce_sum.hpp           | 4 ++--
 test/unit/math/rev/functor/reduce_sum_test.cpp | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/stan/math/prim/functor/reduce_sum.hpp b/stan/math/prim/functor/reduce_sum.hpp
index 93bb3f42b0c..b9ff07e2a0e 100644
--- a/stan/math/prim/functor/reduce_sum.hpp
+++ b/stan/math/prim/functor/reduce_sum.hpp
@@ -1,8 +1,8 @@
 #ifndef STAN_MATH_PRIM_SCAL_FUNCTOR_REDUCE_SUM_HPP
 #define STAN_MATH_PRIM_SCAL_FUNCTOR_REDUCE_SUM_HPP
 
-#include <stan/math/prim/meta/return_type.hpp>
-#include <stan/math/prim/fun/typedefs.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/fun.hpp>
 
 #include <boost/iterator/counting_iterator.hpp>
 
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index e7696a9c8a9..0b09c63c97d 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -2,8 +2,8 @@
 #define STAN_MATH_REV_SCAL_FUNCTOR_REDUCE_SUM_HPP
 
 #include <stan/math/prim/meta.hpp>
-#include <stan/math/rev/fun/typedefs.hpp>
-
+#include <stan/math/prim/functor.hpp>
+#include <stan/math/rev/fun.hpp>
 #include <tbb/task_arena.h>
 #include <tbb/parallel_reduce.h>
 #include <tbb/blocked_range.h>
diff --git a/test/unit/math/rev/functor/reduce_sum_test.cpp b/test/unit/math/rev/functor/reduce_sum_test.cpp
index ddafa3d75ea..740e280d228 100644
--- a/test/unit/math/rev/functor/reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/reduce_sum_test.cpp
@@ -1,4 +1,4 @@
-#include <stan/math/prim/core/init_threadpool_tbb.hpp>
+#include <stan/math/prim/core.hpp>
 #include <stan/math.hpp>
 #include <gtest/gtest.h>
 #include <algorithm>

From d05d452edf0d25f38b20f4d7eb458b0b01618d7e Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Sat, 18 Jan 2020 21:46:53 -0500
Subject: [PATCH 069/189] Added msgs argument to reduce_sum

---
 stan/math/prim/functor/reduce_sum.hpp         | 22 +++++----
 stan/math/rev/functor/reduce_sum.hpp          | 29 ++++++------
 .../unit/math/mix/functor/reduce_sum_test.cpp |  9 ++--
 .../math/prim/functor/reduce_sum_test.cpp     | 46 ++++++++++++-------
 .../unit/math/rev/functor/reduce_sum_test.cpp | 27 ++++++-----
 5 files changed, 76 insertions(+), 57 deletions(-)

diff --git a/stan/math/prim/functor/reduce_sum.hpp b/stan/math/prim/functor/reduce_sum.hpp
index b9ff07e2a0e..365d50a611e 100644
--- a/stan/math/prim/functor/reduce_sum.hpp
+++ b/stan/math/prim/functor/reduce_sum.hpp
@@ -25,13 +25,14 @@ template <typename ReduceFunction, typename Enable, typename ReturnType,
 struct reduce_sum_impl {
   return_type_t<Vec, Args...> operator()(const Vec& vmapped,
                                          std::size_t grainsize,
+					 std::ostream* msgs,
                                          const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
     if (num_jobs == 0)
       return 0.0;
 
-    return ReduceFunction()(0, vmapped.size() - 1, vmapped, args...);
+    return ReduceFunction()(0, vmapped.size() - 1, vmapped, msgs, args...);
   }
 };
 
@@ -41,16 +42,16 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
                        ReturnType, Vec, Args...> {
   struct recursive_reducer {
     using vmapped_t = Vec;
-    std::tuple<const Args&...> args_tuple_;
-    size_t tuple_size_ = sizeof...(Args);
     const vmapped_t& vmapped_;
+    std::ostream* msgs_;
+    std::tuple<const Args&...> args_tuple_;
     return_type_t<Vec, Args...> sum_;
 
-    recursive_reducer(const vmapped_t& vmapped, const Args&... args)
-        : vmapped_(vmapped), args_tuple_(args...), sum_(0.0) {}
+    recursive_reducer(const vmapped_t& vmapped, std::ostream* msgs, const Args&... args)
+      : vmapped_(vmapped), msgs_(msgs), args_tuple_(args...), sum_(0.0) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-        : vmapped_(other.vmapped_), args_tuple_(other.args_tuple_), sum_(0.0) {}
+      : vmapped_(other.vmapped_), msgs_(other.msgs_), args_tuple_(other.args_tuple_), sum_(0.0) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty()) {
@@ -66,7 +67,7 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
 
       sum_ += apply(
           [&](auto&&... args) {
-            return ReduceFunction()(r.begin(), r.end() - 1, sub_slice, args...);
+            return ReduceFunction()(r.begin(), r.end() - 1, sub_slice, msgs_, args...);
           },
           args_tuple_);
     }
@@ -76,13 +77,14 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
 
   return_type_t<Vec, Args...> operator()(const Vec& vmapped,
                                          std::size_t grainsize,
+					 std::ostream* msgs,
                                          const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
     if (num_jobs == 0)
       return 0.0;
 
-    recursive_reducer worker(vmapped, args...);
+    recursive_reducer worker(vmapped, msgs, args...);
 
 #ifdef STAN_DETERMINISTIC
     tbb::static_partitioner partitioner;
@@ -107,11 +109,11 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
  */
 template <typename ReduceFunction, typename Vec, require_vector_like_t<Vec>...,
           typename... Args>
-auto reduce_sum(const Vec& vmapped, std::size_t grainsize,
+auto reduce_sum(const Vec& vmapped, std::size_t grainsize, std::ostream* msgs,
                 const Args&... args) {
   using return_type = return_type_t<Vec, Args...>;
   return internal::reduce_sum_impl<ReduceFunction, void, return_type, Vec,
-                                   Args...>()(vmapped, grainsize, args...);
+                                   Args...>()(vmapped, grainsize, msgs, args...);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 0b09c63c97d..414be40256b 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -92,29 +92,31 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
 
   struct recursive_reducer {
     size_t num_shared_terms_;
+    double* sliced_partials_;
     const Vec& vmapped_;
+    std::ostream* msgs_;
     std::tuple<const Args&...> args_tuple_;
-    size_t tuple_size_ = sizeof...(Args);
 
     double sum_;
-    double* sliced_partials_;
     Eigen::VectorXd args_adjoints_;
 
     recursive_reducer(size_t num_shared_terms, double* sliced_partials,
-                      const Vec& vmapped, const Args&... args)
+                      const Vec& vmapped, std::ostream* msgs, const Args&... args)
         : num_shared_terms_(num_shared_terms),
+          sliced_partials_(sliced_partials),
           vmapped_(vmapped),
+	  msgs_(msgs),
           args_tuple_(args...),
           sum_(0.0),
-          sliced_partials_(sliced_partials),
           args_adjoints_(Eigen::VectorXd::Zero(num_shared_terms_)) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
         : num_shared_terms_(other.num_shared_terms_),
+          sliced_partials_(other.sliced_partials_),
           vmapped_(other.vmapped_),
+	  msgs_(other.msgs_),
           args_tuple_(other.args_tuple_),
           sum_(0.0),
-          sliced_partials_(other.sliced_partials_),
           args_adjoints_(Eigen::VectorXd::Zero(num_shared_terms_)) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
@@ -127,15 +129,12 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
         // create a deep copy of all var's so that these are not
         // linked to any outer AD tree
         Vec local_sub_slice(r.size());
-        // local_sub_slice.reserve(r.size());
         int ii = 0;
         for (int i = r.begin(); i < r.end(); ++i) {
           local_sub_slice[ii] = deep_copy(vmapped_[i]);
           ii++;
         }
 
-        // auto local_sub_slice = deep_copy(sub_slice);
-
         auto args_tuple_local_copy = apply(
             [&](auto&&... args) {
               return std::tuple<decltype(deep_copy(args))...>(
@@ -143,12 +142,10 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
             },
             args_tuple_);
 
-        var sub_sum_v = apply(
-            [&r, &local_sub_slice](auto&&... args) {
-              return ReduceFunction()(r.begin(), r.end() - 1, local_sub_slice,
-                                      args...);
-            },
-            args_tuple_local_copy);
+        var sub_sum_v = apply([&](auto&&... args) {
+	    return ReduceFunction()(r.begin(), r.end() - 1, local_sub_slice, msgs_, args...);
+	  },
+	  args_tuple_local_copy);
 
         sub_sum_v.grad();
 
@@ -244,7 +241,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   void save_varis(vari** /* v */) const {}
 
   var operator()(const Vec& vmapped, std::size_t grainsize,
-                 const Args&... args) const {
+		 std::ostream* msgs, const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
     if (num_jobs == 0)
@@ -263,7 +260,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
 
     double sum = 0;
 
-    recursive_reducer worker(num_shared_terms, partials, vmapped, args...);
+    recursive_reducer worker(num_shared_terms, partials, vmapped, msgs, args...);
 
 #ifdef STAN_DETERMINISTIC
     tbb::static_partitioner partitioner;
diff --git a/test/unit/math/mix/functor/reduce_sum_test.cpp b/test/unit/math/mix/functor/reduce_sum_test.cpp
index f78a00efce8..8dca2401131 100644
--- a/test/unit/math/mix/functor/reduce_sum_test.cpp
+++ b/test/unit/math/mix/functor/reduce_sum_test.cpp
@@ -2,6 +2,8 @@
 #include <limits>
 #include <vector>
 
+std::ostream* msgs = nullptr;
+
 template <typename T>
 T sum_(const T& arg) {
   return arg;
@@ -21,6 +23,7 @@ struct sum_lpdf {
   template <typename T, typename... Args>
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<T>& sub_slice,
+			 std::ostream* msgs,
                          const Args&... args) const {
     using return_type = stan::return_type_t<T, Args...>;
 
@@ -33,7 +36,7 @@ struct sum_lpdf {
 
 TEST(MathMix_reduce_sum, double_slice) {
   auto f = [](const auto& data) {
-    return stan::math::reduce_sum<sum_lpdf>(data, 0);
+    return stan::math::reduce_sum<sum_lpdf>(data, 0, msgs);
   };
 
   std::vector<double> data(5, 10.0);
@@ -42,12 +45,12 @@ TEST(MathMix_reduce_sum, double_slice) {
 }
 
 auto fi = [](const auto&... args) {
-  return stan::math::reduce_sum<sum_lpdf>(std::vector<int>(2, 10.0), 0,
+  return stan::math::reduce_sum<sum_lpdf>(std::vector<int>(2, 10.0), 0, msgs,
                                           args...);
 };
 
 auto fd = [](const auto& data, const auto&... args) {
-  return stan::math::reduce_sum<sum_lpdf>(data, 0, args...);
+  return stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, args...);
 };
 
 TEST(MathMix_reduce_sum, int_arg) {
diff --git a/test/unit/math/prim/functor/reduce_sum_test.cpp b/test/unit/math/prim/functor/reduce_sum_test.cpp
index 84b9ea5e0d9..d7feb12cacb 100644
--- a/test/unit/math/prim/functor/reduce_sum_test.cpp
+++ b/test/unit/math/prim/functor/reduce_sum_test.cpp
@@ -6,6 +6,8 @@
 #include <tuple>
 #include <vector>
 
+std::ostream* msgs = nullptr;
+
 // reduce functor which is the BinaryFunction
 // here we use iterators which represent integer indices
 template <typename T>
@@ -15,6 +17,7 @@ struct count_lpdf {
   // does the reduction in the sub-slice start to end
   inline T operator()(std::size_t start, std::size_t end,
                       const std::vector<int>& sub_slice,
+		      std::ostream* msgs,
                       const std::vector<T>& lambda,
                       const std::vector<int>& idata) const {
     return stan::math::poisson_lpmf(sub_slice, lambda[0]);
@@ -38,7 +41,7 @@ TEST(StanMath_reduce_sum, value) {
   typedef boost::counting_iterator<std::size_t> count_iter;
 
   double poisson_lpdf
-      = stan::math::reduce_sum<count_lpdf<double>>(data, 5, vlambda_d, idata);
+    = stan::math::reduce_sum<count_lpdf<double>>(data, 5, msgs, vlambda_d, idata);
 
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
 
@@ -56,9 +59,10 @@ struct nesting_count_lpdf {
   // does the reduction in the sub-slice start to end
   inline T operator()(std::size_t start, std::size_t end,
                       const std::vector<int>& sub_slice,
+		      std::ostream* msgs,
                       const std::vector<T>& lambda,
                       const std::vector<int>& idata) const {
-    return stan::math::reduce_sum<count_lpdf<T>>(sub_slice, 5, lambda, idata);
+    return stan::math::reduce_sum<count_lpdf<T>>(sub_slice, 5, msgs, lambda, idata);
   }
 };
 
@@ -79,7 +83,7 @@ TEST(StanMath_reduce_sum, nesting_value) {
   typedef boost::counting_iterator<std::size_t> count_iter;
 
   double poisson_lpdf
-      = stan::math::reduce_sum<count_lpdf<double>>(data, 5, vlambda_d, idata);
+    = stan::math::reduce_sum<count_lpdf<double>>(data, 5, msgs, vlambda_d, idata);
 
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
 
@@ -88,14 +92,16 @@ TEST(StanMath_reduce_sum, nesting_value) {
 
 struct int_slice_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<int>& sub_slice) const {
+                         const std::vector<int>& sub_slice,
+			 std::ostream* msgs) const {
     return stan::math::sum(sub_slice);
   }
 };
 
 struct double_slice_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<double>& sub_slice) const {
+                         const std::vector<double>& sub_slice,
+			 std::ostream* msgs) const {
     return stan::math::sum(sub_slice);
   }
 };
@@ -105,7 +111,7 @@ TEST(StanMath_reduce_sum, int_slice) {
 
   std::vector<int> data(5, 10);
 
-  EXPECT_EQ(50, stan::math::reduce_sum<int_slice_lpdf>(data, 0));
+  EXPECT_EQ(50, stan::math::reduce_sum<int_slice_lpdf>(data, 0, msgs));
 }
 
 TEST(StanMath_reduce_sum, double_slice) {
@@ -113,12 +119,13 @@ TEST(StanMath_reduce_sum, double_slice) {
 
   std::vector<double> data(5, 10.0);
 
-  EXPECT_DOUBLE_EQ(50.0, stan::math::reduce_sum<double_slice_lpdf>(data, 0));
+  EXPECT_DOUBLE_EQ(50.0, stan::math::reduce_sum<double_slice_lpdf>(data, 0, msgs));
 }
 
 struct int_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
+			 std::ostream* msgs,
                          const int& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * arg;
   }
@@ -127,6 +134,7 @@ struct int_arg_lpdf {
 struct double_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
+			 std::ostream* msgs,
                          const double& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * arg;
   }
@@ -135,6 +143,7 @@ struct double_arg_lpdf {
 struct std_vector_int_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
+			 std::ostream* msgs,
                          const std::vector<int>& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
   }
@@ -143,6 +152,7 @@ struct std_vector_int_arg_lpdf {
 struct std_vector_double_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
+			 std::ostream* msgs,
                          const std::vector<double>& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
   }
@@ -151,6 +161,7 @@ struct std_vector_double_arg_lpdf {
 struct eigen_vector_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
+			 std::ostream* msgs,
                          const Eigen::VectorXd& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
   }
@@ -159,6 +170,7 @@ struct eigen_vector_arg_lpdf {
 struct eigen_row_vector_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
+			 std::ostream* msgs,
                          const Eigen::RowVectorXd& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
   }
@@ -167,6 +179,7 @@ struct eigen_row_vector_arg_lpdf {
 struct eigen_matrix_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
+			 std::ostream* msgs,
                          const Eigen::MatrixXd& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
   }
@@ -179,7 +192,7 @@ TEST(StanMath_reduce_sum, int_arg) {
   int arg = 5;
 
   EXPECT_DOUBLE_EQ(5 * (10 + 5),
-                   stan::math::reduce_sum<int_arg_lpdf>(data, 0, arg));
+                   stan::math::reduce_sum<int_arg_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMath_reduce_sum, double_arg) {
@@ -189,7 +202,7 @@ TEST(StanMath_reduce_sum, double_arg) {
   double arg = 5.0;
 
   EXPECT_DOUBLE_EQ(5 * (10.0 + 5.0),
-                   stan::math::reduce_sum<double_arg_lpdf>(data, 0, arg));
+                   stan::math::reduce_sum<double_arg_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMath_reduce_sum, std_vector_int_arg) {
@@ -200,7 +213,7 @@ TEST(StanMath_reduce_sum, std_vector_int_arg) {
 
   EXPECT_DOUBLE_EQ(
       5 * (10 + 5 * 10),
-      stan::math::reduce_sum<std_vector_int_arg_lpdf>(data, 0, arg));
+      stan::math::reduce_sum<std_vector_int_arg_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMath_reduce_sum, std_vector_double_arg) {
@@ -211,7 +224,7 @@ TEST(StanMath_reduce_sum, std_vector_double_arg) {
 
   EXPECT_DOUBLE_EQ(
       5 * (10 + 5 * 10),
-      stan::math::reduce_sum<std_vector_double_arg_lpdf>(data, 0, arg));
+      stan::math::reduce_sum<std_vector_double_arg_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMath_reduce_sum, eigen_vector_arg) {
@@ -221,7 +234,7 @@ TEST(StanMath_reduce_sum, eigen_vector_arg) {
   Eigen::VectorXd arg = Eigen::VectorXd::Ones(5);
 
   EXPECT_DOUBLE_EQ(5 * (10 + 5),
-                   stan::math::reduce_sum<eigen_vector_arg_lpdf>(data, 0, arg));
+                   stan::math::reduce_sum<eigen_vector_arg_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMath_reduce_sum, eigen_row_vector_arg) {
@@ -232,7 +245,7 @@ TEST(StanMath_reduce_sum, eigen_row_vector_arg) {
 
   EXPECT_DOUBLE_EQ(
       5 * (10 + 5),
-      stan::math::reduce_sum<eigen_row_vector_arg_lpdf>(data, 0, arg));
+      stan::math::reduce_sum<eigen_row_vector_arg_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMath_reduce_sum, eigen_matrix_arg) {
@@ -242,12 +255,13 @@ TEST(StanMath_reduce_sum, eigen_matrix_arg) {
   Eigen::MatrixXd arg = Eigen::MatrixXd::Ones(5, 5);
 
   EXPECT_DOUBLE_EQ(5 * (10 + 5 * 5),
-                   stan::math::reduce_sum<eigen_matrix_arg_lpdf>(data, 0, arg));
+                   stan::math::reduce_sum<eigen_matrix_arg_lpdf>(data, 0, msgs, arg));
 }
 
 struct sum_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<double>& sub_slice, const int& arg1,
+                         const std::vector<double>& sub_slice,
+			 std::ostream* msgs, const int& arg1,
                          const double& arg2, const std::vector<int>& arg3,
                          const std::vector<double>& arg4,
                          const Eigen::VectorXd& arg5,
@@ -274,6 +288,6 @@ TEST(StanMath_reduce_sum, sum) {
   Eigen::MatrixXd arg7 = Eigen::MatrixXd::Ones(5, 5);
 
   EXPECT_DOUBLE_EQ(5 + 5 * (1 + 1 + 5 + 5 + 5 + 5 + 25),
-                   stan::math::reduce_sum<sum_lpdf>(data, 0, arg1, arg2, arg3,
+                   stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg1, arg2, arg3,
                                                     arg4, arg5, arg6, arg7));
 }
diff --git a/test/unit/math/rev/functor/reduce_sum_test.cpp b/test/unit/math/rev/functor/reduce_sum_test.cpp
index ec2597e6192..fd242b72ab2 100644
--- a/test/unit/math/rev/functor/reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/reduce_sum_test.cpp
@@ -6,6 +6,8 @@
 #include <tuple>
 #include <vector>
 
+std::ostream* msgs = nullptr;
+
 // reduce functor which is the BinaryFunction
 // here we use iterators which represent integer indices
 template <typename T>
@@ -15,6 +17,7 @@ struct count_lpdf {
   // does the reduction in the sub-slice start to end
   inline T operator()(std::size_t start, std::size_t end,
                       const std::vector<int>& sub_slice,
+		      std::ostream* msgs,
                       const std::vector<T>& lambda,
                       const std::vector<int>& idata) const {
     return stan::math::poisson_lpmf(sub_slice, lambda[0]);
@@ -38,7 +41,7 @@ TEST(v3_reduce_sum, value) {
   typedef boost::counting_iterator<std::size_t> count_iter;
 
   double poisson_lpdf
-      = stan::math::reduce_sum<count_lpdf<double>>(data, 5, vlambda_d, idata);
+    = stan::math::reduce_sum<count_lpdf<double>>(data, 5, msgs, vlambda_d, idata);
 
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
 
@@ -69,7 +72,7 @@ TEST(v3_reduce_sum, gradient) {
   std::vector<var> vlambda_v(1, lambda_v);
 
   var poisson_lpdf
-      = stan::math::reduce_sum<count_lpdf<var>>(data, 5, vlambda_v, idata);
+    = stan::math::reduce_sum<count_lpdf<var>>(data, 5, msgs, vlambda_v, idata);
 
   var lambda_ref = lambda_d;
   var poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_ref);
@@ -107,9 +110,10 @@ struct nesting_count_lpdf {
   // does the reduction in the sub-slice start to end
   inline T operator()(std::size_t start, std::size_t end,
                       const std::vector<int>& sub_slice,
+		      std::ostream* msgs,
                       const std::vector<T>& lambda,
                       const std::vector<int>& idata) const {
-    return stan::math::reduce_sum<count_lpdf<T>>(sub_slice, 5, lambda, idata);
+    return stan::math::reduce_sum<count_lpdf<T>>(sub_slice, 5, msgs, lambda, idata);
   }
 };
 
@@ -132,8 +136,7 @@ TEST(v3_reduce_sum, nesting_gradient) {
   std::vector<int> idata;
   std::vector<var> vlambda_v(1, lambda_v);
 
-  var poisson_lpdf = stan::math::reduce_sum<nesting_count_lpdf<var>>(
-      data, 5, vlambda_v, idata);
+  var poisson_lpdf = stan::math::reduce_sum<nesting_count_lpdf<var>>(data, 5, msgs, vlambda_v, idata);
 
   var lambda_ref = lambda_d;
   var poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_ref);
@@ -172,7 +175,9 @@ struct grouped_count_lpdf {
   // does the reduction in the sub-slice start to end
   template <typename VecInt1, typename VecT, typename VecInt2>
   inline T operator()(std::size_t start, std::size_t end,
-                      const VecInt1& sub_slice, const VecT& lambda,
+                      const VecInt1& sub_slice,
+		      std::ostream* msgs,
+		      const VecT& lambda,
                       const VecInt2& gidx) const {
     const std::size_t num_terms = end - start + 1;
     // std::cout << "sub-slice " << start << " - " << end << "; num_terms = " <<
@@ -211,8 +216,7 @@ TEST(v3_reduce_sum, grouped_gradient) {
 
   var lambda_v = vlambda_v[0];
 
-  var poisson_lpdf = stan::math::reduce_sum<grouped_count_lpdf<var>>(
-      data, 5, vlambda_v, gidx);
+  var poisson_lpdf = stan::math::reduce_sum<grouped_count_lpdf<var>>(data, 5, msgs, vlambda_v, gidx);
 
   std::vector<var> vref_lambda_v;
   for (std::size_t i = 0; i != elems; ++i) {
@@ -268,8 +272,7 @@ TEST(v3_reduce_sum, grouped_gradient_eigen) {
     vlambda_v[i] = i + 0.2;
   var lambda_v = vlambda_v[0];
 
-  var poisson_lpdf = stan::math::reduce_sum<grouped_count_lpdf<var>>(
-      data, 5, vlambda_v, gidx);
+  var poisson_lpdf = stan::math::reduce_sum<grouped_count_lpdf<var>>(data, 5, msgs, vlambda_v, gidx);
 
   std::vector<var> vref_lambda_v;
   for (std::size_t i = 0; i != elems; ++i) {
@@ -313,6 +316,7 @@ struct slice_group_count_lpdf {
   // does the reduction in the sub-slice start to end
   inline T operator()(std::size_t start, std::size_t end,
                       const std::vector<T>& lambda_slice,
+		      std::ostream* msgs,
                       const std::vector<int>& y,
                       const std::vector<int>& gsidx) const {
     const std::size_t num_groups = end - start + 1;
@@ -357,8 +361,7 @@ TEST(v3_reduce_sum, slice_group_gradient) {
 
   var lambda_v = vlambda_v[0];
 
-  var poisson_lpdf = stan::math::reduce_sum<slice_group_count_lpdf<var>>(
-      vlambda_v, 5, data, gsidx);
+  var poisson_lpdf = stan::math::reduce_sum<slice_group_count_lpdf<var>>(vlambda_v, 5, msgs, data, gsidx);
 
   std::vector<var> vref_lambda_v;
   for (std::size_t i = 0; i != elems; ++i) {

From 4e18f1e2a458288b477394bea9bc0a21a7a307ed Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Sat, 18 Jan 2020 21:48:53 -0500
Subject: [PATCH 070/189] [Jenkins] auto-formatting by clang-format version
 6.0.0 (tags/google/stable/2017-11-14)

---
 stan/math/prim/functor/reduce_sum.hpp         | 20 ++++---
 stan/math/rev/functor/reduce_sum.hpp          | 24 ++++----
 .../unit/math/mix/functor/reduce_sum_test.cpp |  3 +-
 .../math/prim/functor/reduce_sum_test.cpp     | 60 +++++++++----------
 .../unit/math/rev/functor/reduce_sum_test.cpp | 38 ++++++------
 5 files changed, 76 insertions(+), 69 deletions(-)

diff --git a/stan/math/prim/functor/reduce_sum.hpp b/stan/math/prim/functor/reduce_sum.hpp
index 365d50a611e..890c53cb8c7 100644
--- a/stan/math/prim/functor/reduce_sum.hpp
+++ b/stan/math/prim/functor/reduce_sum.hpp
@@ -25,7 +25,7 @@ template <typename ReduceFunction, typename Enable, typename ReturnType,
 struct reduce_sum_impl {
   return_type_t<Vec, Args...> operator()(const Vec& vmapped,
                                          std::size_t grainsize,
-					 std::ostream* msgs,
+                                         std::ostream* msgs,
                                          const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
@@ -47,11 +47,15 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
     std::tuple<const Args&...> args_tuple_;
     return_type_t<Vec, Args...> sum_;
 
-    recursive_reducer(const vmapped_t& vmapped, std::ostream* msgs, const Args&... args)
-      : vmapped_(vmapped), msgs_(msgs), args_tuple_(args...), sum_(0.0) {}
+    recursive_reducer(const vmapped_t& vmapped, std::ostream* msgs,
+                      const Args&... args)
+        : vmapped_(vmapped), msgs_(msgs), args_tuple_(args...), sum_(0.0) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-      : vmapped_(other.vmapped_), msgs_(other.msgs_), args_tuple_(other.args_tuple_), sum_(0.0) {}
+        : vmapped_(other.vmapped_),
+          msgs_(other.msgs_),
+          args_tuple_(other.args_tuple_),
+          sum_(0.0) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty()) {
@@ -67,7 +71,8 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
 
       sum_ += apply(
           [&](auto&&... args) {
-            return ReduceFunction()(r.begin(), r.end() - 1, sub_slice, msgs_, args...);
+            return ReduceFunction()(r.begin(), r.end() - 1, sub_slice, msgs_,
+                                    args...);
           },
           args_tuple_);
     }
@@ -77,7 +82,7 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
 
   return_type_t<Vec, Args...> operator()(const Vec& vmapped,
                                          std::size_t grainsize,
-					 std::ostream* msgs,
+                                         std::ostream* msgs,
                                          const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
@@ -113,7 +118,8 @@ auto reduce_sum(const Vec& vmapped, std::size_t grainsize, std::ostream* msgs,
                 const Args&... args) {
   using return_type = return_type_t<Vec, Args...>;
   return internal::reduce_sum_impl<ReduceFunction, void, return_type, Vec,
-                                   Args...>()(vmapped, grainsize, msgs, args...);
+                                   Args...>()(vmapped, grainsize, msgs,
+                                              args...);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 414be40256b..af0ae35e358 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -101,11 +101,12 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     Eigen::VectorXd args_adjoints_;
 
     recursive_reducer(size_t num_shared_terms, double* sliced_partials,
-                      const Vec& vmapped, std::ostream* msgs, const Args&... args)
+                      const Vec& vmapped, std::ostream* msgs,
+                      const Args&... args)
         : num_shared_terms_(num_shared_terms),
           sliced_partials_(sliced_partials),
           vmapped_(vmapped),
-	  msgs_(msgs),
+          msgs_(msgs),
           args_tuple_(args...),
           sum_(0.0),
           args_adjoints_(Eigen::VectorXd::Zero(num_shared_terms_)) {}
@@ -114,7 +115,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
         : num_shared_terms_(other.num_shared_terms_),
           sliced_partials_(other.sliced_partials_),
           vmapped_(other.vmapped_),
-	  msgs_(other.msgs_),
+          msgs_(other.msgs_),
           args_tuple_(other.args_tuple_),
           sum_(0.0),
           args_adjoints_(Eigen::VectorXd::Zero(num_shared_terms_)) {}
@@ -142,10 +143,12 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
             },
             args_tuple_);
 
-        var sub_sum_v = apply([&](auto&&... args) {
-	    return ReduceFunction()(r.begin(), r.end() - 1, local_sub_slice, msgs_, args...);
-	  },
-	  args_tuple_local_copy);
+        var sub_sum_v = apply(
+            [&](auto&&... args) {
+              return ReduceFunction()(r.begin(), r.end() - 1, local_sub_slice,
+                                      msgs_, args...);
+            },
+            args_tuple_local_copy);
 
         sub_sum_v.grad();
 
@@ -240,8 +243,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
 
   void save_varis(vari** /* v */) const {}
 
-  var operator()(const Vec& vmapped, std::size_t grainsize,
-		 std::ostream* msgs, const Args&... args) const {
+  var operator()(const Vec& vmapped, std::size_t grainsize, std::ostream* msgs,
+                 const Args&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
     if (num_jobs == 0)
@@ -260,7 +263,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
 
     double sum = 0;
 
-    recursive_reducer worker(num_shared_terms, partials, vmapped, msgs, args...);
+    recursive_reducer worker(num_shared_terms, partials, vmapped, msgs,
+                             args...);
 
 #ifdef STAN_DETERMINISTIC
     tbb::static_partitioner partitioner;
diff --git a/test/unit/math/mix/functor/reduce_sum_test.cpp b/test/unit/math/mix/functor/reduce_sum_test.cpp
index 8dca2401131..2399f862907 100644
--- a/test/unit/math/mix/functor/reduce_sum_test.cpp
+++ b/test/unit/math/mix/functor/reduce_sum_test.cpp
@@ -22,8 +22,7 @@ auto sum_(const Eigen::Matrix<T, RowType, ColType>& arg) {
 struct sum_lpdf {
   template <typename T, typename... Args>
   inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<T>& sub_slice,
-			 std::ostream* msgs,
+                         const std::vector<T>& sub_slice, std::ostream* msgs,
                          const Args&... args) const {
     using return_type = stan::return_type_t<T, Args...>;
 
diff --git a/test/unit/math/prim/functor/reduce_sum_test.cpp b/test/unit/math/prim/functor/reduce_sum_test.cpp
index d7feb12cacb..10e5490ec8e 100644
--- a/test/unit/math/prim/functor/reduce_sum_test.cpp
+++ b/test/unit/math/prim/functor/reduce_sum_test.cpp
@@ -16,8 +16,7 @@ struct count_lpdf {
 
   // does the reduction in the sub-slice start to end
   inline T operator()(std::size_t start, std::size_t end,
-                      const std::vector<int>& sub_slice,
-		      std::ostream* msgs,
+                      const std::vector<int>& sub_slice, std::ostream* msgs,
                       const std::vector<T>& lambda,
                       const std::vector<int>& idata) const {
     return stan::math::poisson_lpmf(sub_slice, lambda[0]);
@@ -40,8 +39,8 @@ TEST(StanMath_reduce_sum, value) {
 
   typedef boost::counting_iterator<std::size_t> count_iter;
 
-  double poisson_lpdf
-    = stan::math::reduce_sum<count_lpdf<double>>(data, 5, msgs, vlambda_d, idata);
+  double poisson_lpdf = stan::math::reduce_sum<count_lpdf<double>>(
+      data, 5, msgs, vlambda_d, idata);
 
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
 
@@ -58,11 +57,11 @@ struct nesting_count_lpdf {
 
   // does the reduction in the sub-slice start to end
   inline T operator()(std::size_t start, std::size_t end,
-                      const std::vector<int>& sub_slice,
-		      std::ostream* msgs,
+                      const std::vector<int>& sub_slice, std::ostream* msgs,
                       const std::vector<T>& lambda,
                       const std::vector<int>& idata) const {
-    return stan::math::reduce_sum<count_lpdf<T>>(sub_slice, 5, msgs, lambda, idata);
+    return stan::math::reduce_sum<count_lpdf<T>>(sub_slice, 5, msgs, lambda,
+                                                 idata);
   }
 };
 
@@ -82,8 +81,8 @@ TEST(StanMath_reduce_sum, nesting_value) {
 
   typedef boost::counting_iterator<std::size_t> count_iter;
 
-  double poisson_lpdf
-    = stan::math::reduce_sum<count_lpdf<double>>(data, 5, msgs, vlambda_d, idata);
+  double poisson_lpdf = stan::math::reduce_sum<count_lpdf<double>>(
+      data, 5, msgs, vlambda_d, idata);
 
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
 
@@ -93,7 +92,7 @@ TEST(StanMath_reduce_sum, nesting_value) {
 struct int_slice_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<int>& sub_slice,
-			 std::ostream* msgs) const {
+                         std::ostream* msgs) const {
     return stan::math::sum(sub_slice);
   }
 };
@@ -101,7 +100,7 @@ struct int_slice_lpdf {
 struct double_slice_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
-			 std::ostream* msgs) const {
+                         std::ostream* msgs) const {
     return stan::math::sum(sub_slice);
   }
 };
@@ -119,14 +118,14 @@ TEST(StanMath_reduce_sum, double_slice) {
 
   std::vector<double> data(5, 10.0);
 
-  EXPECT_DOUBLE_EQ(50.0, stan::math::reduce_sum<double_slice_lpdf>(data, 0, msgs));
+  EXPECT_DOUBLE_EQ(50.0,
+                   stan::math::reduce_sum<double_slice_lpdf>(data, 0, msgs));
 }
 
 struct int_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
-			 std::ostream* msgs,
-                         const int& arg) const {
+                         std::ostream* msgs, const int& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * arg;
   }
 };
@@ -134,8 +133,7 @@ struct int_arg_lpdf {
 struct double_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
-			 std::ostream* msgs,
-                         const double& arg) const {
+                         std::ostream* msgs, const double& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * arg;
   }
 };
@@ -143,7 +141,7 @@ struct double_arg_lpdf {
 struct std_vector_int_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
-			 std::ostream* msgs,
+                         std::ostream* msgs,
                          const std::vector<int>& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
   }
@@ -152,7 +150,7 @@ struct std_vector_int_arg_lpdf {
 struct std_vector_double_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
-			 std::ostream* msgs,
+                         std::ostream* msgs,
                          const std::vector<double>& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
   }
@@ -161,8 +159,7 @@ struct std_vector_double_arg_lpdf {
 struct eigen_vector_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
-			 std::ostream* msgs,
-                         const Eigen::VectorXd& arg) const {
+                         std::ostream* msgs, const Eigen::VectorXd& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
   }
 };
@@ -170,7 +167,7 @@ struct eigen_vector_arg_lpdf {
 struct eigen_row_vector_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
-			 std::ostream* msgs,
+                         std::ostream* msgs,
                          const Eigen::RowVectorXd& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
   }
@@ -179,8 +176,7 @@ struct eigen_row_vector_arg_lpdf {
 struct eigen_matrix_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
-			 std::ostream* msgs,
-                         const Eigen::MatrixXd& arg) const {
+                         std::ostream* msgs, const Eigen::MatrixXd& arg) const {
     return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
   }
 };
@@ -233,8 +229,8 @@ TEST(StanMath_reduce_sum, eigen_vector_arg) {
   std::vector<double> data(5, 10.0);
   Eigen::VectorXd arg = Eigen::VectorXd::Ones(5);
 
-  EXPECT_DOUBLE_EQ(5 * (10 + 5),
-                   stan::math::reduce_sum<eigen_vector_arg_lpdf>(data, 0, msgs, arg));
+  EXPECT_DOUBLE_EQ(5 * (10 + 5), stan::math::reduce_sum<eigen_vector_arg_lpdf>(
+                                     data, 0, msgs, arg));
 }
 
 TEST(StanMath_reduce_sum, eigen_row_vector_arg) {
@@ -254,14 +250,15 @@ TEST(StanMath_reduce_sum, eigen_matrix_arg) {
   std::vector<double> data(5, 10.0);
   Eigen::MatrixXd arg = Eigen::MatrixXd::Ones(5, 5);
 
-  EXPECT_DOUBLE_EQ(5 * (10 + 5 * 5),
-                   stan::math::reduce_sum<eigen_matrix_arg_lpdf>(data, 0, msgs, arg));
+  EXPECT_DOUBLE_EQ(
+      5 * (10 + 5 * 5),
+      stan::math::reduce_sum<eigen_matrix_arg_lpdf>(data, 0, msgs, arg));
 }
 
 struct sum_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
-			 std::ostream* msgs, const int& arg1,
+                         std::ostream* msgs, const int& arg1,
                          const double& arg2, const std::vector<int>& arg3,
                          const std::vector<double>& arg4,
                          const Eigen::VectorXd& arg5,
@@ -287,7 +284,8 @@ TEST(StanMath_reduce_sum, sum) {
   Eigen::RowVectorXd arg6 = Eigen::RowVectorXd::Ones(5);
   Eigen::MatrixXd arg7 = Eigen::MatrixXd::Ones(5, 5);
 
-  EXPECT_DOUBLE_EQ(5 + 5 * (1 + 1 + 5 + 5 + 5 + 5 + 25),
-                   stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg1, arg2, arg3,
-                                                    arg4, arg5, arg6, arg7));
+  EXPECT_DOUBLE_EQ(
+      5 + 5 * (1 + 1 + 5 + 5 + 5 + 5 + 25),
+      stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg1, arg2, arg3, arg4,
+                                       arg5, arg6, arg7));
 }
diff --git a/test/unit/math/rev/functor/reduce_sum_test.cpp b/test/unit/math/rev/functor/reduce_sum_test.cpp
index fd242b72ab2..9054d61c3ef 100644
--- a/test/unit/math/rev/functor/reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/reduce_sum_test.cpp
@@ -16,8 +16,7 @@ struct count_lpdf {
 
   // does the reduction in the sub-slice start to end
   inline T operator()(std::size_t start, std::size_t end,
-                      const std::vector<int>& sub_slice,
-		      std::ostream* msgs,
+                      const std::vector<int>& sub_slice, std::ostream* msgs,
                       const std::vector<T>& lambda,
                       const std::vector<int>& idata) const {
     return stan::math::poisson_lpmf(sub_slice, lambda[0]);
@@ -40,8 +39,8 @@ TEST(v3_reduce_sum, value) {
 
   typedef boost::counting_iterator<std::size_t> count_iter;
 
-  double poisson_lpdf
-    = stan::math::reduce_sum<count_lpdf<double>>(data, 5, msgs, vlambda_d, idata);
+  double poisson_lpdf = stan::math::reduce_sum<count_lpdf<double>>(
+      data, 5, msgs, vlambda_d, idata);
 
   double poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_d);
 
@@ -71,8 +70,8 @@ TEST(v3_reduce_sum, gradient) {
   std::vector<int> idata;
   std::vector<var> vlambda_v(1, lambda_v);
 
-  var poisson_lpdf
-    = stan::math::reduce_sum<count_lpdf<var>>(data, 5, msgs, vlambda_v, idata);
+  var poisson_lpdf = stan::math::reduce_sum<count_lpdf<var>>(data, 5, msgs,
+                                                             vlambda_v, idata);
 
   var lambda_ref = lambda_d;
   var poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_ref);
@@ -109,11 +108,11 @@ struct nesting_count_lpdf {
 
   // does the reduction in the sub-slice start to end
   inline T operator()(std::size_t start, std::size_t end,
-                      const std::vector<int>& sub_slice,
-		      std::ostream* msgs,
+                      const std::vector<int>& sub_slice, std::ostream* msgs,
                       const std::vector<T>& lambda,
                       const std::vector<int>& idata) const {
-    return stan::math::reduce_sum<count_lpdf<T>>(sub_slice, 5, msgs, lambda, idata);
+    return stan::math::reduce_sum<count_lpdf<T>>(sub_slice, 5, msgs, lambda,
+                                                 idata);
   }
 };
 
@@ -136,7 +135,8 @@ TEST(v3_reduce_sum, nesting_gradient) {
   std::vector<int> idata;
   std::vector<var> vlambda_v(1, lambda_v);
 
-  var poisson_lpdf = stan::math::reduce_sum<nesting_count_lpdf<var>>(data, 5, msgs, vlambda_v, idata);
+  var poisson_lpdf = stan::math::reduce_sum<nesting_count_lpdf<var>>(
+      data, 5, msgs, vlambda_v, idata);
 
   var lambda_ref = lambda_d;
   var poisson_lpdf_ref = stan::math::poisson_lpmf(data, lambda_ref);
@@ -175,10 +175,8 @@ struct grouped_count_lpdf {
   // does the reduction in the sub-slice start to end
   template <typename VecInt1, typename VecT, typename VecInt2>
   inline T operator()(std::size_t start, std::size_t end,
-                      const VecInt1& sub_slice,
-		      std::ostream* msgs,
-		      const VecT& lambda,
-                      const VecInt2& gidx) const {
+                      const VecInt1& sub_slice, std::ostream* msgs,
+                      const VecT& lambda, const VecInt2& gidx) const {
     const std::size_t num_terms = end - start + 1;
     // std::cout << "sub-slice " << start << " - " << end << "; num_terms = " <<
     // num_terms << "; size = " << sub_slice.size() << std::endl;
@@ -216,7 +214,8 @@ TEST(v3_reduce_sum, grouped_gradient) {
 
   var lambda_v = vlambda_v[0];
 
-  var poisson_lpdf = stan::math::reduce_sum<grouped_count_lpdf<var>>(data, 5, msgs, vlambda_v, gidx);
+  var poisson_lpdf = stan::math::reduce_sum<grouped_count_lpdf<var>>(
+      data, 5, msgs, vlambda_v, gidx);
 
   std::vector<var> vref_lambda_v;
   for (std::size_t i = 0; i != elems; ++i) {
@@ -272,7 +271,8 @@ TEST(v3_reduce_sum, grouped_gradient_eigen) {
     vlambda_v[i] = i + 0.2;
   var lambda_v = vlambda_v[0];
 
-  var poisson_lpdf = stan::math::reduce_sum<grouped_count_lpdf<var>>(data, 5, msgs, vlambda_v, gidx);
+  var poisson_lpdf = stan::math::reduce_sum<grouped_count_lpdf<var>>(
+      data, 5, msgs, vlambda_v, gidx);
 
   std::vector<var> vref_lambda_v;
   for (std::size_t i = 0; i != elems; ++i) {
@@ -315,8 +315,7 @@ struct slice_group_count_lpdf {
 
   // does the reduction in the sub-slice start to end
   inline T operator()(std::size_t start, std::size_t end,
-                      const std::vector<T>& lambda_slice,
-		      std::ostream* msgs,
+                      const std::vector<T>& lambda_slice, std::ostream* msgs,
                       const std::vector<int>& y,
                       const std::vector<int>& gsidx) const {
     const std::size_t num_groups = end - start + 1;
@@ -361,7 +360,8 @@ TEST(v3_reduce_sum, slice_group_gradient) {
 
   var lambda_v = vlambda_v[0];
 
-  var poisson_lpdf = stan::math::reduce_sum<slice_group_count_lpdf<var>>(vlambda_v, 5, msgs, data, gsidx);
+  var poisson_lpdf = stan::math::reduce_sum<slice_group_count_lpdf<var>>(
+      vlambda_v, 5, msgs, data, gsidx);
 
   std::vector<var> vref_lambda_v;
   for (std::size_t i = 0; i != elems; ++i) {

From d834a4fdfdfe4cde9153c6e69c2af01886284deb Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Sun, 19 Jan 2020 21:48:40 -0500
Subject: [PATCH 071/189] Allow arrays of all the Stan types to reduce_sum

---
 stan/math/rev/functor/reduce_sum.hpp          | 85 ++++++++++++++-----
 .../unit/math/mix/functor/reduce_sum_test.cpp | 66 ++++++++++++--
 .../math/prim/functor/reduce_sum_test.cpp     | 63 +++++++++++++-
 3 files changed, 183 insertions(+), 31 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index af0ae35e358..040dab2ee2c 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -22,7 +22,8 @@ template <typename ReduceFunction, typename ReturnType, typename Vec,
           typename... Args>
 struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
                        Vec, Args...> {
-  template <typename T>
+  template <typename T,
+	    require_arithmetic_t<scalar_type_t<T>>...>
   static const T& deep_copy(const T& arg) {
     return arg;
   }
@@ -37,6 +38,16 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     return copy;
   }
 
+  template <typename T,
+	    require_t<is_var<scalar_type_t<T>>>...>
+  static std::vector<T> deep_copy(const std::vector<T>& arg) {
+    std::vector<T> copy(arg.size());
+    for (size_t i = 0; i < arg.size(); ++i) {
+      copy[i] = deep_copy(arg[i]);
+    }
+    return copy;
+  }
+
   template <int RowType, int ColType>
   static Eigen::Matrix<var, RowType, ColType> deep_copy(
       const Eigen::Matrix<var, RowType, ColType>& arg) {
@@ -59,10 +70,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     return accumulate_adjoints(dest + 1, args...);
   }
 
-  // Works with anything that has operator[Integral] defined
-  template <typename... Pargs, typename VecVar,
-            require_std_vector_vt<is_var, VecVar>...>
-  static double* accumulate_adjoints(double* dest, const VecVar& x,
+  template <typename... Pargs>
+  static double* accumulate_adjoints(double* dest, const std::vector<var>& x,
                                      const Pargs&... args) {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] += x[i].adj();
@@ -70,6 +79,17 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     return accumulate_adjoints(dest + x.size(), args...);
   }
 
+  template <typename T,
+	    require_t<is_var<scalar_type_t<T>>>...,
+	    typename... Pargs>
+  static double* accumulate_adjoints(double* dest, const std::vector<T>& x,
+                                     const Pargs&... args) {
+    for (size_t i = 0; i < x.size(); ++i) {
+      dest = accumulate_adjoints(dest, x[i]);
+    }
+    return accumulate_adjoints(dest, args...);
+  }
+
   // Works on anything with a operator()
   template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
   static double* accumulate_adjoints(double* dest, const Mat& x,
@@ -178,11 +198,25 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   template <typename T>
   using member_size_t = decltype(std::declval<T>().size());
 
-  // TODO(Steve): add requires for generic containers
-  template <typename Container,
-            require_t<is_detected<Container, member_size_t>>...,
-            require_t<is_var<value_type_t<Container>>>..., typename... Pargs>
-  size_t count_var_impl(size_t count, const Container& x,
+  template <typename... Pargs>
+  size_t count_var_impl(size_t count, const std::vector<var>& x,
+                        const Pargs&... args) const {
+    return count_var_impl(count + x.size(), args...);
+  }
+
+  template <typename T,
+	    require_t<is_var<scalar_type_t<T>>>...,
+	    typename... Pargs>
+  size_t count_var_impl(size_t count, const std::vector<T>& x,
+                        const Pargs&... args) const {
+    for(size_t i = 0; i < x.size(); i++) {
+      count = count_var_impl(count, x[i]);
+    }
+    return count_var_impl(count, args...);
+  }
+
+  template <typename Mat, require_eigen_vt<is_var, Mat>..., typename... Pargs>
+  size_t count_var_impl(size_t count, const Mat& x,
                         const Pargs&... args) const {
     return count_var_impl(count + x.size(), args...);
   }
@@ -213,35 +247,44 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   template <typename... Pargs>
-  void save_varis(vari** dest, const var& x, const Pargs&... args) const {
+  vari** save_varis(vari** dest, const var& x, const Pargs&... args) const {
     *dest = x.vi_;
-    save_varis(dest + 1, args...);
+    return save_varis(dest + 1, args...);
   }
 
-  template <typename... Pargs, typename VecVar,
-            require_std_vector_vt<is_var, VecVar>...>
-  void save_varis(vari** dest, const VecVar& x, const Pargs&... args) const {
+  template <typename... Pargs>
+  vari** save_varis(vari** dest, const std::vector<var>& x, const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x[i].vi_;
     }
-    save_varis(dest + x.size(), args...);
+    return save_varis(dest + x.size(), args...);
+  }
+
+  template <typename T,
+	    require_t<is_var<scalar_type_t<T>>>...,
+	    typename... Pargs>
+  vari** save_varis(vari** dest, const std::vector<T>& x, const Pargs&... args) const {
+    for (size_t i = 0; i < x.size(); ++i) {
+      dest = save_varis(dest, x[i]);
+    }
+    return save_varis(dest, args...);
   }
 
   template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
-  void save_varis(vari** dest, const Mat& x, const Pargs&... args) const {
+  vari** save_varis(vari** dest, const Mat& x, const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x(i).vi_;
     }
-    save_varis(dest + x.size(), args...);
+    return save_varis(dest + x.size(), args...);
   }
 
   template <typename R, require_arithmetic_t<scalar_type_t<R>>...,
             typename... Pargs>
-  void save_varis(vari** dest, const R& x, const Pargs&... args) const {
-    save_varis(dest, args...);
+  vari** save_varis(vari** dest, const R& x, const Pargs&... args) const {
+    return save_varis(dest, args...);
   }
 
-  void save_varis(vari** /* v */) const {}
+  vari** save_varis(vari** dest) const { return dest; }
 
   var operator()(const Vec& vmapped, std::size_t grainsize, std::ostream* msgs,
                  const Args&... args) const {
diff --git a/test/unit/math/mix/functor/reduce_sum_test.cpp b/test/unit/math/mix/functor/reduce_sum_test.cpp
index 2399f862907..cfade5cbaec 100644
--- a/test/unit/math/mix/functor/reduce_sum_test.cpp
+++ b/test/unit/math/mix/functor/reduce_sum_test.cpp
@@ -5,20 +5,24 @@
 std::ostream* msgs = nullptr;
 
 template <typename T>
-T sum_(const T& arg) {
+T sum_(T arg) {
   return arg;
 }
 
-template <typename T>
-auto sum_(const std::vector<T>& arg) {
-  return stan::math::sum(arg);
-}
-
 template <typename T, int RowType, int ColType>
 auto sum_(const Eigen::Matrix<T, RowType, ColType>& arg) {
   return stan::math::sum(arg);
 }
 
+template <typename T>
+auto sum_(const std::vector<T>& arg) {
+  stan::scalar_type_t<T> sum = 0;
+  for(size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
+  }
+  return sum;
+}
+
 struct sum_lpdf {
   template <typename T, typename... Args>
   inline auto operator()(std::size_t start, std::size_t end,
@@ -106,6 +110,22 @@ TEST(MathMix_reduce_sum, eigen_matrix_arg) {
   stan::test::expect_ad(fd, data, arg);
 }
 
+TEST(MathMix_reduce_sum, std_vector_std_vector_double_arg) {
+  std::vector<double> data(2, 10.0);
+  std::vector<std::vector<double>> arg(2, std::vector<double>(2, 10.0));
+
+  stan::test::expect_ad(fi, arg);
+  stan::test::expect_ad(fd, data, arg);
+}
+
+TEST(MathMix_reduce_sum, std_vector_eigen_vector_arg) {
+  std::vector<double> data(2, 10.0);
+  std::vector<Eigen::VectorXd> arg(2, Eigen::VectorXd::Ones(2));
+
+  stan::test::expect_ad(fi, arg);
+  stan::test::expect_ad(fd, data, arg);
+}
+
 TEST(MathMix_reduce_sum, eigen_three_args1) {
   Eigen::VectorXd arg1 = Eigen::VectorXd::Ones(2);
   Eigen::RowVectorXd arg2 = Eigen::RowVectorXd::Ones(2);
@@ -122,6 +142,14 @@ TEST(MathMix_reduce_sum, eigen_three_args2) {
   stan::test::expect_ad(fi, arg1, arg2, arg3);
 }
 
+TEST(MathMix_reduce_sum, eigen_three_args3) {
+  double arg1 = 1.0;
+  std::vector<std::vector<double>> arg2(2, std::vector<double>(2, 1.0));
+  std::vector<Eigen::MatrixXd> arg3(2, Eigen::MatrixXd::Ones(2, 2));
+
+  stan::test::expect_ad(fi, arg1, arg2, arg3);
+}
+
 TEST(MathMix_reduce_sum, eigen_three_args_with_ints1) {
   Eigen::VectorXd arg1 = Eigen::VectorXd::Ones(2);
   Eigen::RowVectorXd arg2 = Eigen::RowVectorXd::Ones(2);
@@ -146,6 +174,18 @@ TEST(MathMix_reduce_sum, eigen_three_args_with_ints2) {
       arg1, arg2, arg3);
 }
 
+TEST(MathMix_reduce_sum, eigen_three_args_with_ints3) {
+  double arg1 = 1.0;
+  std::vector<std::vector<double>> arg2(2, std::vector<double>(2, 1.0));
+  std::vector<Eigen::MatrixXd> arg3(2, Eigen::MatrixXd::Ones(2, 2));
+
+  stan::test::expect_ad(
+      [&](const auto& arg1, const auto& arg2, const auto& arg3) {
+        return fi(1, arg1, std::vector<int>{1, 2, 3}, arg2, 3, arg3);
+      },
+      arg1, arg2, arg3);
+}
+
 TEST(MathMix_reduce_sum, eigen_three_args_with_doubles1) {
   Eigen::VectorXd arg1 = Eigen::VectorXd::Ones(2);
   Eigen::RowVectorXd arg2 = Eigen::RowVectorXd::Ones(2);
@@ -171,3 +211,17 @@ TEST(MathMix_reduce_sum, eigen_three_args_with_doubles2) {
       },
       arg1, arg2, arg3);
 }
+
+TEST(MathMix_reduce_sum, eigen_three_args_with_doubles3) {
+  double arg1 = 1.0;
+  std::vector<std::vector<double>> arg2(2, std::vector<double>(2, 1.0));
+  std::vector<Eigen::MatrixXd> arg3(2, Eigen::MatrixXd::Ones(2, 2));
+
+  stan::test::expect_ad(
+      [&](const auto& arg1, const auto& arg2, const auto& arg3) {
+        return fi(std::vector<double>{1.0, 2.0, 3.0}, arg1, 3.0, arg2,
+                  std::vector<double>{1.0, 2.0, 3.0}, arg3);
+      },
+      arg1, arg2, arg3);
+}
+
diff --git a/test/unit/math/prim/functor/reduce_sum_test.cpp b/test/unit/math/prim/functor/reduce_sum_test.cpp
index 10e5490ec8e..91ecea720e9 100644
--- a/test/unit/math/prim/functor/reduce_sum_test.cpp
+++ b/test/unit/math/prim/functor/reduce_sum_test.cpp
@@ -255,6 +255,50 @@ TEST(StanMath_reduce_sum, eigen_matrix_arg) {
       stan::math::reduce_sum<eigen_matrix_arg_lpdf>(data, 0, msgs, arg));
 }
 
+struct std_vector_std_vector_double_arg_lpdf {
+  inline auto operator()(std::size_t start, std::size_t end,
+                         const std::vector<double>& sub_slice,
+                         std::ostream* msgs,
+                         const std::vector<std::vector<double>>& arg) const {
+    double sum = 0.0;
+    for(size_t i = 0; i < arg.size(); ++i)
+      sum += stan::math::sum(arg[i]);
+    return stan::math::sum(sub_slice) + sub_slice.size() * sum;
+  }
+};
+
+struct std_vector_eigen_vector_arg_lpdf {
+  inline auto operator()(std::size_t start, std::size_t end,
+                         const std::vector<double>& sub_slice,
+                         std::ostream* msgs, const std::vector<Eigen::VectorXd>& arg) const {
+    double sum = 0.0;
+    for(size_t i = 0; i < arg.size(); ++i)
+      sum += stan::math::sum(arg[i]);
+    return stan::math::sum(sub_slice) + sub_slice.size() * sum;
+  }
+};
+
+TEST(StanMath_reduce_sum, std_vector_std_vector_double_arg) {
+  stan::math::init_threadpool_tbb();
+
+  std::vector<double> data(5, 10.0);
+  std::vector<std::vector<double>> arg(5, std::vector<double>(5, 10.0));
+
+  EXPECT_DOUBLE_EQ(
+      5 * (10 + 250),
+      stan::math::reduce_sum<std_vector_std_vector_double_arg_lpdf>(data, 0, msgs, arg));
+}
+
+TEST(StanMath_reduce_sum, std_vector_eigen_vector_arg) {
+  stan::math::init_threadpool_tbb();
+
+  std::vector<double> data(5, 10.0);
+  std::vector<Eigen::VectorXd> arg(2, Eigen::VectorXd::Ones(5));
+
+  EXPECT_DOUBLE_EQ(5 * (10 + 10), stan::math::reduce_sum<std_vector_eigen_vector_arg_lpdf>(
+                                     data, 0, msgs, arg));
+}
+
 struct sum_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
@@ -263,12 +307,21 @@ struct sum_lpdf {
                          const std::vector<double>& arg4,
                          const Eigen::VectorXd& arg5,
                          const Eigen::RowVectorXd& arg6,
-                         const Eigen::MatrixXd& arg7) const {
+                         const Eigen::MatrixXd& arg7,
+			 const std::vector<std::vector<double>>& arg8,
+			 const std::vector<Eigen::VectorXd>& arg9) const {
+    double sum8 = 0.0;
+    double sum9 = 0.0;
+    for(size_t i = 0; i < arg8.size(); ++i)
+      sum8 += stan::math::sum(arg8[i]);
+    for(size_t i = 0; i < arg9.size(); ++i)
+      sum9 += stan::math::sum(arg9[i]);
     return stan::math::sum(sub_slice)
            + sub_slice.size()
                  * (arg1 + arg2 + stan::math::sum(arg3) + stan::math::sum(arg4)
                     + stan::math::sum(arg5) + stan::math::sum(arg6)
-                    + stan::math::sum(arg7));
+                    + stan::math::sum(arg7)
+		    + sum8 + sum9);
   }
 };
 
@@ -283,9 +336,11 @@ TEST(StanMath_reduce_sum, sum) {
   Eigen::VectorXd arg5 = Eigen::VectorXd::Ones(5);
   Eigen::RowVectorXd arg6 = Eigen::RowVectorXd::Ones(5);
   Eigen::MatrixXd arg7 = Eigen::MatrixXd::Ones(5, 5);
+  std::vector<std::vector<double>> arg8(2, arg4);
+  std::vector<Eigen::VectorXd> arg9(2, arg5);
 
   EXPECT_DOUBLE_EQ(
-      5 + 5 * (1 + 1 + 5 + 5 + 5 + 5 + 25),
+      5 + 5 * (1 + 1 + 5 + 5 + 5 + 5 + 25 + 10 + 10),
       stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg1, arg2, arg3, arg4,
-                                       arg5, arg6, arg7));
+                                       arg5, arg6, arg7, arg8, arg9));
 }

From 145ae95e33db3074d978537ab36908511f86ff26 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Sun, 19 Jan 2020 21:51:16 -0500
Subject: [PATCH 072/189] [Jenkins] auto-formatting by clang-format version
 6.0.0 (tags/google/stable/2017-11-14)

---
 stan/math/rev/functor/reduce_sum.hpp          | 29 +++++++-------
 .../unit/math/mix/functor/reduce_sum_test.cpp |  3 +-
 .../math/prim/functor/reduce_sum_test.cpp     | 39 +++++++++----------
 3 files changed, 33 insertions(+), 38 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 040dab2ee2c..f4c77877256 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -22,8 +22,7 @@ template <typename ReduceFunction, typename ReturnType, typename Vec,
           typename... Args>
 struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
                        Vec, Args...> {
-  template <typename T,
-	    require_arithmetic_t<scalar_type_t<T>>...>
+  template <typename T, require_arithmetic_t<scalar_type_t<T>>...>
   static const T& deep_copy(const T& arg) {
     return arg;
   }
@@ -38,8 +37,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     return copy;
   }
 
-  template <typename T,
-	    require_t<is_var<scalar_type_t<T>>>...>
+  template <typename T, require_t<is_var<scalar_type_t<T>>>...>
   static std::vector<T> deep_copy(const std::vector<T>& arg) {
     std::vector<T> copy(arg.size());
     for (size_t i = 0; i < arg.size(); ++i) {
@@ -79,9 +77,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     return accumulate_adjoints(dest + x.size(), args...);
   }
 
-  template <typename T,
-	    require_t<is_var<scalar_type_t<T>>>...,
-	    typename... Pargs>
+  template <typename T, require_t<is_var<scalar_type_t<T>>>...,
+            typename... Pargs>
   static double* accumulate_adjoints(double* dest, const std::vector<T>& x,
                                      const Pargs&... args) {
     for (size_t i = 0; i < x.size(); ++i) {
@@ -204,12 +201,11 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     return count_var_impl(count + x.size(), args...);
   }
 
-  template <typename T,
-	    require_t<is_var<scalar_type_t<T>>>...,
-	    typename... Pargs>
+  template <typename T, require_t<is_var<scalar_type_t<T>>>...,
+            typename... Pargs>
   size_t count_var_impl(size_t count, const std::vector<T>& x,
                         const Pargs&... args) const {
-    for(size_t i = 0; i < x.size(); i++) {
+    for (size_t i = 0; i < x.size(); i++) {
       count = count_var_impl(count, x[i]);
     }
     return count_var_impl(count, args...);
@@ -253,17 +249,18 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   template <typename... Pargs>
-  vari** save_varis(vari** dest, const std::vector<var>& x, const Pargs&... args) const {
+  vari** save_varis(vari** dest, const std::vector<var>& x,
+                    const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest[i] = x[i].vi_;
     }
     return save_varis(dest + x.size(), args...);
   }
 
-  template <typename T,
-	    require_t<is_var<scalar_type_t<T>>>...,
-	    typename... Pargs>
-  vari** save_varis(vari** dest, const std::vector<T>& x, const Pargs&... args) const {
+  template <typename T, require_t<is_var<scalar_type_t<T>>>...,
+            typename... Pargs>
+  vari** save_varis(vari** dest, const std::vector<T>& x,
+                    const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest = save_varis(dest, x[i]);
     }
diff --git a/test/unit/math/mix/functor/reduce_sum_test.cpp b/test/unit/math/mix/functor/reduce_sum_test.cpp
index cfade5cbaec..27815db29be 100644
--- a/test/unit/math/mix/functor/reduce_sum_test.cpp
+++ b/test/unit/math/mix/functor/reduce_sum_test.cpp
@@ -17,7 +17,7 @@ auto sum_(const Eigen::Matrix<T, RowType, ColType>& arg) {
 template <typename T>
 auto sum_(const std::vector<T>& arg) {
   stan::scalar_type_t<T> sum = 0;
-  for(size_t i = 0; i < arg.size(); ++i) {
+  for (size_t i = 0; i < arg.size(); ++i) {
     sum += sum_(arg[i]);
   }
   return sum;
@@ -224,4 +224,3 @@ TEST(MathMix_reduce_sum, eigen_three_args_with_doubles3) {
       },
       arg1, arg2, arg3);
 }
-
diff --git a/test/unit/math/prim/functor/reduce_sum_test.cpp b/test/unit/math/prim/functor/reduce_sum_test.cpp
index 91ecea720e9..55d690d5099 100644
--- a/test/unit/math/prim/functor/reduce_sum_test.cpp
+++ b/test/unit/math/prim/functor/reduce_sum_test.cpp
@@ -261,7 +261,7 @@ struct std_vector_std_vector_double_arg_lpdf {
                          std::ostream* msgs,
                          const std::vector<std::vector<double>>& arg) const {
     double sum = 0.0;
-    for(size_t i = 0; i < arg.size(); ++i)
+    for (size_t i = 0; i < arg.size(); ++i)
       sum += stan::math::sum(arg[i]);
     return stan::math::sum(sub_slice) + sub_slice.size() * sum;
   }
@@ -270,9 +270,10 @@ struct std_vector_std_vector_double_arg_lpdf {
 struct std_vector_eigen_vector_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
-                         std::ostream* msgs, const std::vector<Eigen::VectorXd>& arg) const {
+                         std::ostream* msgs,
+                         const std::vector<Eigen::VectorXd>& arg) const {
     double sum = 0.0;
-    for(size_t i = 0; i < arg.size(); ++i)
+    for (size_t i = 0; i < arg.size(); ++i)
       sum += stan::math::sum(arg[i]);
     return stan::math::sum(sub_slice) + sub_slice.size() * sum;
   }
@@ -286,7 +287,8 @@ TEST(StanMath_reduce_sum, std_vector_std_vector_double_arg) {
 
   EXPECT_DOUBLE_EQ(
       5 * (10 + 250),
-      stan::math::reduce_sum<std_vector_std_vector_double_arg_lpdf>(data, 0, msgs, arg));
+      stan::math::reduce_sum<std_vector_std_vector_double_arg_lpdf>(data, 0,
+                                                                    msgs, arg));
 }
 
 TEST(StanMath_reduce_sum, std_vector_eigen_vector_arg) {
@@ -295,33 +297,30 @@ TEST(StanMath_reduce_sum, std_vector_eigen_vector_arg) {
   std::vector<double> data(5, 10.0);
   std::vector<Eigen::VectorXd> arg(2, Eigen::VectorXd::Ones(5));
 
-  EXPECT_DOUBLE_EQ(5 * (10 + 10), stan::math::reduce_sum<std_vector_eigen_vector_arg_lpdf>(
-                                     data, 0, msgs, arg));
+  EXPECT_DOUBLE_EQ(5 * (10 + 10),
+                   stan::math::reduce_sum<std_vector_eigen_vector_arg_lpdf>(
+                       data, 0, msgs, arg));
 }
 
 struct sum_lpdf {
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<double>& sub_slice,
-                         std::ostream* msgs, const int& arg1,
-                         const double& arg2, const std::vector<int>& arg3,
-                         const std::vector<double>& arg4,
-                         const Eigen::VectorXd& arg5,
-                         const Eigen::RowVectorXd& arg6,
-                         const Eigen::MatrixXd& arg7,
-			 const std::vector<std::vector<double>>& arg8,
-			 const std::vector<Eigen::VectorXd>& arg9) const {
+  inline auto operator()(
+      std::size_t start, std::size_t end, const std::vector<double>& sub_slice,
+      std::ostream* msgs, const int& arg1, const double& arg2,
+      const std::vector<int>& arg3, const std::vector<double>& arg4,
+      const Eigen::VectorXd& arg5, const Eigen::RowVectorXd& arg6,
+      const Eigen::MatrixXd& arg7, const std::vector<std::vector<double>>& arg8,
+      const std::vector<Eigen::VectorXd>& arg9) const {
     double sum8 = 0.0;
     double sum9 = 0.0;
-    for(size_t i = 0; i < arg8.size(); ++i)
+    for (size_t i = 0; i < arg8.size(); ++i)
       sum8 += stan::math::sum(arg8[i]);
-    for(size_t i = 0; i < arg9.size(); ++i)
+    for (size_t i = 0; i < arg9.size(); ++i)
       sum9 += stan::math::sum(arg9[i]);
     return stan::math::sum(sub_slice)
            + sub_slice.size()
                  * (arg1 + arg2 + stan::math::sum(arg3) + stan::math::sum(arg4)
                     + stan::math::sum(arg5) + stan::math::sum(arg6)
-                    + stan::math::sum(arg7)
-		    + sum8 + sum9);
+                    + stan::math::sum(arg7) + sum8 + sum9);
   }
 };
 

From 99579095d59c2cf3e67d5c2c2b16ccc58a005b86 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 20 Jan 2020 09:17:13 -0500
Subject: [PATCH 073/189] Allocate deep copied varis on no-chain stack

---
 stan/math/rev/functor/reduce_sum.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index f4c77877256..59fa751fb7d 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -27,12 +27,12 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     return arg;
   }
 
-  static var deep_copy(const var& arg) { return var(arg.val()); }
+  static var deep_copy(const var& arg) { return var(new vari(arg.val(), false)); }
 
   static std::vector<var> deep_copy(const std::vector<var>& arg) {
     std::vector<var> copy(arg.size());
     for (size_t i = 0; i < arg.size(); ++i) {
-      copy[i] = arg[i].val();
+      copy[i] = new vari(arg[i].val(), false);
     }
     return copy;
   }
@@ -51,7 +51,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
       const Eigen::Matrix<var, RowType, ColType>& arg) {
     Eigen::Matrix<var, RowType, ColType> copy(arg.rows(), arg.cols());
     for (size_t i = 0; i < arg.size(); ++i) {
-      copy(i) = arg(i).val();
+      copy(i) = new vari(arg(i).val(), false);
     }
     return copy;
   }

From 3ecf79e03a44ac279a64d7d212c106ec336fbd80 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 20 Jan 2020 09:18:26 -0500
Subject: [PATCH 074/189] [Jenkins] auto-formatting by clang-format version
 5.0.2-svn328729-1~exp1~20180509124008.99 (branches/release_50)

---
 stan/math/rev/functor/reduce_sum.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 59fa751fb7d..80acb306e5b 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -27,7 +27,9 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     return arg;
   }
 
-  static var deep_copy(const var& arg) { return var(new vari(arg.val(), false)); }
+  static var deep_copy(const var& arg) {
+    return var(new vari(arg.val(), false));
+  }
 
   static std::vector<var> deep_copy(const std::vector<var>& arg) {
     std::vector<var> copy(arg.size());

From 3c56f6d7e0c434537301e9aac8e511ba589255cc Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Sat, 25 Jan 2020 17:32:14 -0500
Subject: [PATCH 075/189] Initial commit of variadic ode functions with
 existing tests working

---
 stan/math/prim/functor.hpp                    |   3 -
 stan/math/prim/functor/coupled_ode_system.hpp | 126 ------
 stan/math/rev/fun.hpp                         |   4 +
 stan/math/rev/fun/accumulate_adjoints.hpp     |  83 ++++
 stan/math/rev/fun/count_vars.hpp              |  85 ++++
 stan/math/rev/fun/deep_copy.hpp               |  51 +++
 stan/math/rev/fun/save_varis.hpp              |  77 ++++
 stan/math/rev/functor.hpp                     |   2 +
 .../functor/coupled_ode_observer.hpp          | 111 +++--
 stan/math/rev/functor/coupled_ode_system.hpp  | 422 +++---------------
 stan/math/rev/functor/cvodes_integrator.hpp   |  41 +-
 stan/math/rev/functor/cvodes_ode_data.hpp     |  46 +-
 stan/math/rev/functor/integrate_ode_bdf.hpp   |   4 +-
 .../functor/integrate_ode_rk45.hpp            |  39 +-
 .../functor/integrate_ode_bdf_prim_test.cpp   |  13 +-
 .../functor/integrate_ode_bdf_rev_test.cpp    |   5 +-
 .../functor/integrate_ode_rk45_prim_test.cpp} | 124 +++--
 ...st.cpp => integrate_ode_rk45_rev_test.cpp} |  41 +-
 test/unit/math/rev/functor/util.hpp           | 107 ++---
 .../unit/math/rev/functor/util_cvodes_bdf.hpp |  12 +-
 20 files changed, 634 insertions(+), 762 deletions(-)
 delete mode 100644 stan/math/prim/functor/coupled_ode_system.hpp
 create mode 100644 stan/math/rev/fun/accumulate_adjoints.hpp
 create mode 100644 stan/math/rev/fun/count_vars.hpp
 create mode 100644 stan/math/rev/fun/deep_copy.hpp
 create mode 100644 stan/math/rev/fun/save_varis.hpp
 rename stan/math/{prim => rev}/functor/coupled_ode_observer.hpp (54%)
 rename stan/math/{prim => rev}/functor/integrate_ode_rk45.hpp (82%)
 rename test/unit/math/{prim/functor/integrate_ode_rk45_test.cpp => rev/functor/integrate_ode_rk45_prim_test.cpp} (50%)
 rename test/unit/math/rev/functor/{integrate_ode_rk45_test.cpp => integrate_ode_rk45_rev_test.cpp} (75%)

diff --git a/stan/math/prim/functor.hpp b/stan/math/prim/functor.hpp
index 1e87c7f0c52..80eb8555642 100644
--- a/stan/math/prim/functor.hpp
+++ b/stan/math/prim/functor.hpp
@@ -2,15 +2,12 @@
 #define STAN_MATH_PRIM_FUNCTOR_HPP
 
 #include <stan/math/prim/functor/apply.hpp>
-#include <stan/math/prim/functor/coupled_ode_observer.hpp>
-#include <stan/math/prim/functor/coupled_ode_system.hpp>
 #include <stan/math/prim/functor/finite_diff_gradient.hpp>
 #include <stan/math/prim/functor/finite_diff_gradient_auto.hpp>
 #include <stan/math/prim/functor/finite_diff_hessian.hpp>
 #include <stan/math/prim/functor/finite_diff_hessian_auto.hpp>
 #include <stan/math/prim/functor/finite_diff_hessian_helper.hpp>
 #include <stan/math/prim/functor/integrate_1d.hpp>
-#include <stan/math/prim/functor/integrate_ode_rk45.hpp>
 #include <stan/math/prim/functor/left_fold.hpp>
 #include <stan/math/prim/functor/map_rect.hpp>
 #include <stan/math/prim/functor/map_rect_combine.hpp>
diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
deleted file mode 100644
index 53c14c1ed0f..00000000000
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ /dev/null
@@ -1,126 +0,0 @@
-#ifndef STAN_MATH_PRIM_FUNCTOR_COUPLED_ODE_SYSTEM_HPP
-#define STAN_MATH_PRIM_FUNCTOR_COUPLED_ODE_SYSTEM_HPP
-
-#include <stan/math/prim/err.hpp>
-#include <ostream>
-#include <vector>
-
-namespace stan {
-namespace math {
-
-/**
- * The <code>coupled_ode_system</code> represents the coupled ode
- * system, which is the base ode and the sensitivities of the base ode
- * (derivatives with respect to the parameters of the base ode).
- *
- * This class provides a functor to be used by ode solvers, a class method
- * for the size of the coupled ode system, a class method to retrieve the
- * initial state, and a class method to convert from the coupled ode system
- * back to the base ode.
- *
- * @tparam F base ode system functor. Must provide
- *   <code>operator()(double t, std::vector<T1> y, std::vector<T2> theta,
- *          std::vector<double> x, std::vector<int>x_int, std::ostream*
- * msgs)</code>
- * @tparam T1 scalar type of the initial state
- * @tparam T2 scalar type of the parameters
- */
-template <typename F, typename T1, typename T2>
-struct coupled_ode_system {};
-
-/**
- * <code>coupled_ode_system</code> specialization for for known
- * initial values and known parameters.
- *
- * For this case, the coupled ode is the same as the base ode. There
- * are no sensitivity parameters and the size of the coupled ode
- * system is the size of the base ode system.
- *
- * @tparam F base ode system functor. Must provide
- *   <code>operator()(double t, std::vector<double> y,
- *   std::vector<double> theta, std::vector<double> x,
- *   std::vector<int>x_int, std::ostream* msgs)</code>
- */
-template <typename F>
-class coupled_ode_system<F, double, double> {
- public:
-  const F& f_;
-  const std::vector<double>& y0_dbl_;
-  const std::vector<double>& theta_dbl_;
-  const std::vector<double>& x_;
-  const std::vector<int>& x_int_;
-  const size_t N_;
-  const size_t M_;
-  const size_t size_;
-  std::ostream* msgs_;
-
-  /**
-   * Construct the coupled ode system from the base system function,
-   * initial state of the base system, parameters, data and a stream
-   * for messages.
-   *
-   * @param[in] f base ode system functor
-   * @param[in] y0 initial state of the base ode
-   * @param[in] theta parameters of the base ode
-   * @param[in] x real data
-   * @param[in] x_int integer data
-   * @param[in, out] msgs stream for messages
-   */
-  coupled_ode_system(const F& f, const std::vector<double>& y0,
-                     const std::vector<double>& theta,
-                     const std::vector<double>& x,
-                     const std::vector<int>& x_int, std::ostream* msgs)
-      : f_(f),
-        y0_dbl_(y0),
-        theta_dbl_(theta),
-        x_(x),
-        x_int_(x_int),
-        N_(y0.size()),
-        M_(theta.size()),
-        size_(N_),
-        msgs_(msgs) {}
-
-  /**
-   * Calculates the derivative of the coupled ode system with respect to time.
-   *
-   * @param[in] y current state of the coupled ode. This must be the
-   *   correct size, <code>N_</code>.
-   * @param[out] dy_dt populated with derivatives of the coupled
-   *   system evaluated at specified state and time. This vector will be
-   * overwritten.
-   * @param[in] t time.
-   * @throw exception if the system function does not return
-   * a derivative vector of the same size as the state vector.
-   */
-  void operator()(const std::vector<double>& y, std::vector<double>& dy_dt,
-                  double t) const {
-    dy_dt = f_(t, y, theta_dbl_, x_, x_int_, msgs_);
-    check_size_match("coupled_ode_system", "y", y.size(), "dy_dt",
-                     dy_dt.size());
-  }
-
-  /**
-   * Returns the size of the coupled system.
-   *
-   * @return size of the coupled system.
-   */
-  int size() const { return size_; }
-
-  /**
-   * Returns the initial state of the coupled system. Here, it is
-   * identical to base ode state because the initial state is known.
-   *
-   * @return initial state of the coupled system
-   */
-  std::vector<double> initial_state() const {
-    std::vector<double> state(size_, 0.0);
-    for (size_t n = 0; n < N_; n++) {
-      state[n] = y0_dbl_[n];
-    }
-    return state;
-  }
-};
-
-}  // namespace math
-}  // namespace stan
-#endif
diff --git a/stan/math/rev/fun.hpp b/stan/math/rev/fun.hpp
index 1deb92f9738..423f2f02787 100644
--- a/stan/math/rev/fun.hpp
+++ b/stan/math/rev/fun.hpp
@@ -10,6 +10,7 @@
 #include <stan/math/rev/fun/Phi.hpp>
 #include <stan/math/rev/fun/Phi_approx.hpp>
 #include <stan/math/rev/fun/abs.hpp>
+#include <stan/math/rev/fun/accumulate_adjoints.hpp>
 #include <stan/math/rev/fun/acos.hpp>
 #include <stan/math/rev/fun/acosh.hpp>
 #include <stan/math/rev/fun/as_bool.hpp>
@@ -30,8 +31,10 @@
 #include <stan/math/rev/fun/columns_dot_self.hpp>
 #include <stan/math/rev/fun/cos.hpp>
 #include <stan/math/rev/fun/cosh.hpp>
+#include <stan/math/rev/fun/count_vars.hpp>
 #include <stan/math/rev/fun/cov_exp_quad.hpp>
 #include <stan/math/rev/fun/crossprod.hpp>
+#include <stan/math/rev/fun/deep_copy.hpp>
 #include <stan/math/rev/fun/determinant.hpp>
 #include <stan/math/rev/fun/digamma.hpp>
 #include <stan/math/rev/fun/divide.hpp>
@@ -114,6 +117,7 @@
 #include <stan/math/rev/fun/rising_factorial.hpp>
 #include <stan/math/rev/fun/round.hpp>
 #include <stan/math/rev/fun/rows_dot_product.hpp>
+#include <stan/math/rev/fun/save_varis.hpp>
 #include <stan/math/rev/fun/sd.hpp>
 #include <stan/math/rev/fun/simplex_constrain.hpp>
 #include <stan/math/rev/fun/sin.hpp>
diff --git a/stan/math/rev/fun/accumulate_adjoints.hpp b/stan/math/rev/fun/accumulate_adjoints.hpp
new file mode 100644
index 00000000000..83873984e08
--- /dev/null
+++ b/stan/math/rev/fun/accumulate_adjoints.hpp
@@ -0,0 +1,83 @@
+#ifndef STAN_MATH_REV_FUN_ACCUMULATE_ADJOINTS_HPP
+#define STAN_MATH_REV_FUN_ACCUMULATE_ADJOINTS_HPP
+
+#include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/core.hpp>
+#include <cmath>
+
+namespace stan {
+namespace math {
+
+namespace internal {
+
+double* accumulate_adjoints(double* x) { return x; }
+
+template <typename... Pargs>
+double* accumulate_adjoints(double* dest, const var& x,
+			    const Pargs&... args);
+
+template <typename... Pargs>
+double* accumulate_adjoints(double* dest, const std::vector<var>& x,
+			    const Pargs&... args);
+
+template <typename T, require_t<is_var<scalar_type_t<T>>>...,
+	  typename... Pargs>
+double* accumulate_adjoints(double* dest, const std::vector<T>& x,
+			    const Pargs&... args);
+
+template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
+double* accumulate_adjoints(double* dest, const Mat& x,
+			    const Pargs&... args);
+
+template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>...,
+	  typename... Pargs>
+double* accumulate_adjoints(double* dest, Arith&& x,
+			    const Pargs&... args);
+
+template <typename... Pargs>
+double* accumulate_adjoints(double* dest, const var& x,
+			    const Pargs&... args) {
+  *dest += x.adj();
+  return accumulate_adjoints(dest + 1, args...);
+}
+
+template <typename... Pargs>
+double* accumulate_adjoints(double* dest, const std::vector<var>& x,
+			    const Pargs&... args) {
+  for (size_t i = 0; i < x.size(); ++i) {
+    dest[i] += x[i].adj();
+  }
+  return accumulate_adjoints(dest + x.size(), args...);
+}
+
+template <typename T, require_t<is_var<scalar_type_t<T>>>...,
+	  typename... Pargs>
+double* accumulate_adjoints(double* dest, const std::vector<T>& x,
+			    const Pargs&... args) {
+  for (size_t i = 0; i < x.size(); ++i) {
+    dest = accumulate_adjoints(dest, x[i]);
+  }
+  return accumulate_adjoints(dest, args...);
+}
+
+template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
+double* accumulate_adjoints(double* dest, const Mat& x,
+			    const Pargs&... args) {
+  for (size_t i = 0; i < x.size(); ++i) {
+    dest[i] += x(i).adj();
+  }
+  return accumulate_adjoints(dest + x.size(), args...);
+}
+
+template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>...,
+	  typename... Pargs>
+double* accumulate_adjoints(double* dest, Arith&& x,
+			    const Pargs&... args) {
+  return accumulate_adjoints(dest, args...);
+}
+
+}  // namespace internal
+
+}  // namespace math
+}  // namespace stan
+#endif
diff --git a/stan/math/rev/fun/count_vars.hpp b/stan/math/rev/fun/count_vars.hpp
new file mode 100644
index 00000000000..84c834863ed
--- /dev/null
+++ b/stan/math/rev/fun/count_vars.hpp
@@ -0,0 +1,85 @@
+#ifndef STAN_MATH_REV_FUN_COUNT_VARS_HPP
+#define STAN_MATH_REV_FUN_COUNT_VARS_HPP
+
+#include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/core.hpp>
+#include <cmath>
+
+namespace stan {
+namespace math {
+
+namespace internal {
+
+size_t count_vars_impl(size_t count) { return count; }
+
+template <typename... Pargs>
+size_t count_vars_impl(size_t count, const std::vector<var>& x,
+		      const Pargs&... args);
+
+template <typename T, require_t<is_var<scalar_type_t<T>>>...,
+	  typename... Pargs>
+size_t count_vars_impl(size_t count, const std::vector<T>& x,
+		      const Pargs&... args);
+
+template <typename Mat, require_eigen_vt<is_var, Mat>..., typename... Pargs>
+size_t count_vars_impl(size_t count, const Mat& x,
+		      const Pargs&... args);
+
+template <typename... Pargs>
+size_t count_vars_impl(size_t count, const var& x,
+		      const Pargs&... args);
+
+template <typename... Pargs, typename Arith,
+	  require_arithmetic_t<scalar_type_t<Arith>>...>
+size_t count_vars_impl(size_t count, Arith& x, const Pargs&... args);
+
+template <typename... Pargs>
+size_t count_vars_impl(size_t count, const std::vector<var>& x,
+		      const Pargs&... args) {
+  return count_vars_impl(count + x.size(), args...);
+}
+
+template <typename T, require_t<is_var<scalar_type_t<T>>>...,
+	  typename... Pargs>
+size_t count_vars_impl(size_t count, const std::vector<T>& x,
+		      const Pargs&... args) {
+  for (size_t i = 0; i < x.size(); i++) {
+    count = count_vars_impl(count, x[i]);
+  }
+  return count_vars_impl(count, args...);
+}
+
+template <typename Mat, require_eigen_vt<is_var, Mat>..., typename... Pargs>
+size_t count_vars_impl(size_t count, const Mat& x,
+		      const Pargs&... args) {
+  return count_vars_impl(count + x.size(), args...);
+}
+
+template <typename... Pargs>
+size_t count_vars_impl(size_t count, const var& x,
+		      const Pargs&... args) {
+  return count_vars_impl(count + 1, args...);
+}
+
+template <typename... Pargs, typename Arith,
+	  require_arithmetic_t<scalar_type_t<Arith>>...>
+size_t count_vars_impl(size_t count, Arith& x, const Pargs&... args) {
+  return count_vars_impl(count, args...);
+}
+
+/**
+ * Count the number of scalars of type T in the input argument list
+ *
+ * @tparam Pargs Types of input arguments
+ * @return Number of scalars of type T in input
+ */
+template <typename... Pargs>
+size_t count_vars(const Pargs&... args) {
+  return count_vars_impl(0, args...);
+}
+
+}  // namespace internal
+
+}  // namespace math
+}  // namespace stan
+#endif
diff --git a/stan/math/rev/fun/deep_copy.hpp b/stan/math/rev/fun/deep_copy.hpp
new file mode 100644
index 00000000000..a287ae38b26
--- /dev/null
+++ b/stan/math/rev/fun/deep_copy.hpp
@@ -0,0 +1,51 @@
+#ifndef STAN_MATH_REV_FUN_DEEP_COPY_HPP
+#define STAN_MATH_REV_FUN_DEEP_COPY_HPP
+
+#include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/core.hpp>
+#include <cmath>
+
+namespace stan {
+namespace math {
+
+namespace internal {
+
+template <typename T, require_arithmetic_t<scalar_type_t<T>>...>
+const T& deep_copy(const T& arg) {
+  return arg;
+}
+
+var deep_copy(const var& arg) {
+  return var(new vari(arg.val(), false));
+}
+
+std::vector<var> deep_copy(const std::vector<var>& arg) {
+  std::vector<var> copy(arg.size());
+  for (size_t i = 0; i < arg.size(); ++i) {
+    copy[i] = new vari(arg[i].val(), false);
+  }
+  return copy;
+}
+
+template <typename T, require_t<is_var<scalar_type_t<T>>>...>
+std::vector<T> deep_copy(const std::vector<T>& arg) {
+  std::vector<T> copy(arg.size());
+  for (size_t i = 0; i < arg.size(); ++i) {
+    copy[i] = deep_copy(arg[i]);
+  }
+  return copy;
+}
+
+template <int RowType, int ColType>
+Eigen::Matrix<var, RowType, ColType> deep_copy(const Eigen::Matrix<var, RowType, ColType>& arg) {
+  Eigen::Matrix<var, RowType, ColType> copy(arg.rows(), arg.cols());
+  for (size_t i = 0; i < arg.size(); ++i) {
+    copy(i) = new vari(arg(i).val(), false);
+  }
+  return copy;
+}
+}  // namespace internal
+
+}  // namespace math
+}  // namespace stan
+#endif
diff --git a/stan/math/rev/fun/save_varis.hpp b/stan/math/rev/fun/save_varis.hpp
new file mode 100644
index 00000000000..bfda34d23c2
--- /dev/null
+++ b/stan/math/rev/fun/save_varis.hpp
@@ -0,0 +1,77 @@
+#ifndef STAN_MATH_REV_FUN_SAVE_VARIS_HPP
+#define STAN_MATH_REV_FUN_SAVE_VARIS_HPP
+
+#include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/core.hpp>
+#include <cmath>
+
+namespace stan {
+namespace math {
+
+namespace internal {
+
+vari** save_varis(vari** dest) { return dest; }
+
+template <typename... Pargs>
+vari** save_varis(vari** dest, const var& x, const Pargs&... args);
+
+template <typename... Pargs>
+vari** save_varis(vari** dest, const std::vector<var>& x,
+		  const Pargs&... args);
+
+template <typename T, require_t<is_var<scalar_type_t<T>>>...,
+	  typename... Pargs>
+vari** save_varis(vari** dest, const std::vector<T>& x,
+		  const Pargs&... args);
+
+template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
+vari** save_varis(vari** dest, const Mat& x, const Pargs&... args);
+
+template <typename R, require_arithmetic_t<scalar_type_t<R>>...,
+	  typename... Pargs>
+vari** save_varis(vari** dest, const R& x, const Pargs&... args);
+
+template <typename... Pargs>
+vari** save_varis(vari** dest, const var& x, const Pargs&... args) {
+  *dest = x.vi_;
+  return save_varis(dest + 1, args...);
+}
+
+template <typename... Pargs>
+vari** save_varis(vari** dest, const std::vector<var>& x,
+		  const Pargs&... args) {
+  for (size_t i = 0; i < x.size(); ++i) {
+    dest[i] = x[i].vi_;
+  }
+  return save_varis(dest + x.size(), args...);
+}
+
+template <typename T, require_t<is_var<scalar_type_t<T>>>...,
+	  typename... Pargs>
+vari** save_varis(vari** dest, const std::vector<T>& x,
+		  const Pargs&... args) {
+  for (size_t i = 0; i < x.size(); ++i) {
+    dest = save_varis(dest, x[i]);
+  }
+  return save_varis(dest, args...);
+}
+
+template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
+vari** save_varis(vari** dest, const Mat& x, const Pargs&... args) {
+  for (size_t i = 0; i < x.size(); ++i) {
+    dest[i] = x(i).vi_;
+  }
+  return save_varis(dest + x.size(), args...);
+}
+
+template <typename R, require_arithmetic_t<scalar_type_t<R>>...,
+	  typename... Pargs>
+vari** save_varis(vari** dest, const R& x, const Pargs&... args) {
+  return save_varis(dest, args...);
+}
+
+}  // namespace internal
+
+}  // namespace math
+}  // namespace stan
+#endif
diff --git a/stan/math/rev/functor.hpp b/stan/math/rev/functor.hpp
index 13566d8b8bc..3b2e7f8da17 100644
--- a/stan/math/rev/functor.hpp
+++ b/stan/math/rev/functor.hpp
@@ -6,6 +6,7 @@
 #include <stan/math/rev/functor/algebra_solver_powell.hpp>
 #include <stan/math/rev/functor/algebra_solver_newton.hpp>
 #include <stan/math/rev/functor/algebra_system.hpp>
+#include <stan/math/rev/functor/coupled_ode_observer.hpp>
 #include <stan/math/rev/functor/coupled_ode_system.hpp>
 #include <stan/math/rev/functor/cvodes_integrator.hpp>
 #include <stan/math/rev/functor/cvodes_ode_data.hpp>
@@ -15,6 +16,7 @@
 #include <stan/math/rev/functor/integrate_dae.hpp>
 #include <stan/math/rev/functor/integrate_ode_adams.hpp>
 #include <stan/math/rev/functor/integrate_ode_bdf.hpp>
+#include <stan/math/rev/functor/integrate_ode_rk45.hpp>
 #include <stan/math/rev/functor/jacobian.hpp>
 #include <stan/math/rev/functor/kinsol_data.hpp>
 #include <stan/math/rev/functor/kinsol_solve.hpp>
diff --git a/stan/math/prim/functor/coupled_ode_observer.hpp b/stan/math/rev/functor/coupled_ode_observer.hpp
similarity index 54%
rename from stan/math/prim/functor/coupled_ode_observer.hpp
rename to stan/math/rev/functor/coupled_ode_observer.hpp
index a3f2cc0043f..263de2b9649 100644
--- a/stan/math/prim/functor/coupled_ode_observer.hpp
+++ b/stan/math/rev/functor/coupled_ode_observer.hpp
@@ -1,6 +1,7 @@
-#ifndef STAN_MATH_PRIM_FUNCTOR_COUPLED_ODE_OBSERVER_HPP
-#define STAN_MATH_PRIM_FUNCTOR_COUPLED_ODE_OBSERVER_HPP
+#ifndef STAN_MATH_REV_FUNCTOR_COUPLED_ODE_OBSERVER_HPP
+#define STAN_MATH_REV_FUNCTOR_COUPLED_ODE_OBSERVER_HPP
 
+#include <stan/math/rev/functor/cvodes_utils.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/sum.hpp>
@@ -25,25 +26,18 @@ namespace math {
  * used in stan-math.
  *
  */
-template <typename F, typename T1, typename T2, typename T_t0, typename T_ts>
+template <typename T1, typename T_t0, typename T_ts, typename F, typename... Args>
 struct coupled_ode_observer {
-  using return_t = return_type_t<T1, T2, T_t0, T_ts>;
-
-  using ops_partials_t
-      = operands_and_partials<std::vector<T1>, std::vector<T2>, T_t0, T_ts>;
-
+  using ReturnType = return_type_t<T1, T_t0, T_ts, Args...>;
+  
   const F& f_;
   const std::vector<T1>& y0_;
   const T_t0& t0_;
   const std::vector<T_ts>& ts_;
-  const std::vector<T2>& theta_;
-  const std::vector<double>& x_;
-  const std::vector<int>& x_int_;
   std::ostream* msgs_;
-  std::vector<std::vector<return_t>>& y_;
+  std::vector<std::vector<ReturnType>>& y_;
   const std::size_t N_;
-  const std::size_t M_;
-  const std::size_t index_offset_theta_;
+  std::tuple<const Args&...> args_tuple_;
   int next_ts_index_;
 
   /**
@@ -66,24 +60,21 @@ struct coupled_ode_observer {
    * @param[out] msgs the print stream for warning messages.
    * @param[out] y reference to a vector of vector of the final return
    */
-  coupled_ode_observer(const F& f, const std::vector<T1>& y0,
-                       const std::vector<T2>& theta, const T_t0& t0,
+  coupled_ode_observer(const F& f,
+		       const std::vector<T1>& y0,
+		       const T_t0& t0,
                        const std::vector<T_ts>& ts,
-                       const std::vector<double>& x,
-                       const std::vector<int>& x_int, std::ostream* msgs,
-                       std::vector<std::vector<return_t>>& y)
+		       const Args&... args,
+		       std::ostream* msgs,
+                       std::vector<std::vector<ReturnType>>& y)
       : f_(f),
         y0_(y0),
         t0_(t0),
         ts_(ts),
-        theta_(theta),
-        x_(x),
-        x_int_(x_int),
         msgs_(msgs),
         y_(y),
+	args_tuple_(args...),
         N_(y0.size()),
-        M_(theta.size()),
-        index_offset_theta_(is_constant_all<T1>::value ? 0 : N_ * N_),
         next_ts_index_(0) {}
 
   /**
@@ -99,50 +90,78 @@ struct coupled_ode_observer {
    * @param t time of solution. The time must correspond to the
    * element ts[next_ts_index_]
    */
-  void operator()(const std::vector<double>& coupled_state, double t) {
+  template<bool return_type_is_var = is_var<ReturnType>::value>
+  std::enable_if_t<return_type_is_var>
+  operator()(const std::vector<double>& coupled_state, double t) {
     check_less("coupled_ode_observer", "time-state number", next_ts_index_,
                ts_.size());
-
-    std::vector<return_t> yt;
+    
+    std::vector<ReturnType> yt;
     yt.reserve(N_);
 
-    ops_partials_t ops_partials(y0_, theta_, t0_, ts_[next_ts_index_]);
-
     std::vector<double> dy_dt;
-    if (!is_constant_all<T_ts>::value) {
+    if (stan::is_var<T_ts>::value) {
       std::vector<double> y_dbl(coupled_state.begin(),
                                 coupled_state.begin() + N_);
-      dy_dt = f_(value_of(ts_[next_ts_index_]), y_dbl, value_of(theta_), x_,
-                 x_int_, msgs_);
-      check_size_match("coupled_ode_observer", "dy_dt", dy_dt.size(), "states",
-                       N_);
+      dy_dt = apply([&](const Args&... args) {
+	  return f_(value_of(ts_[next_ts_index_]), y_dbl, value_of(args)..., msgs_);
+	}, args_tuple_);
+      check_size_match("coupled_ode_observer", "dy_dt", dy_dt.size(), "states", N_);
     }
 
+    const size_t y0_vars = internal::count_vars(y0_);
+    const size_t args_vars = apply([&](const Args&... args) { return internal::count_vars(args...); }, args_tuple_);
+    // When true this is 1 and not ts_.size() because there's
+    //   only one time point involved with this output
+    const size_t time_vars = (stan::is_var<T_ts>::value) ? 1 : 0;
+    const size_t total_vars = y0_vars + args_vars + time_vars;
+    
     for (size_t j = 0; j < N_; j++) {
+      vari** varis = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
+      double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(total_vars);
+
+      vari** varis_ptr = varis;
+      double* partials_ptr = partials;
+
+      size_t offset = 0;
+
       // iterate over parameters for each equation
-      if (!is_constant_all<T1>::value) {
-        for (std::size_t k = 0; k < N_; k++) {
-          ops_partials.edge1_.partials_[k] = coupled_state[N_ + N_ * k + j];
-        }
+      varis_ptr = internal::save_varis(varis_ptr, y0_);
+      for (std::size_t k = 0; k < y0_vars; k++) {
+	//*varis_ptr = y0[k].vi_;
+	*partials_ptr = coupled_state[N_ + y0_vars * k + j];
+	partials_ptr++;
       }
 
-      if (!is_constant_all<T2>::value) {
-        for (std::size_t k = 0; k < M_; k++) {
-          ops_partials.edge2_.partials_[k]
-              = coupled_state[N_ + index_offset_theta_ + N_ * k + j];
-        }
+      varis_ptr = apply([&varis_ptr](const Args&... args) {
+	  return internal::save_varis(varis_ptr, args...);
+	}, args_tuple_);
+      for (std::size_t k = 0; k < args_vars; k++) {
+	// dy[j]_dtheta[k]
+	// theta[k].vi_
+	*partials_ptr = coupled_state[N_ + N_ * y0_vars + N_ * k + j];
+	partials_ptr++;
       }
 
-      if (!is_constant_all<T_ts>::value) {
-        ops_partials.edge4_.partials_[0] = dy_dt[j];
+      if (time_vars > 0) {
+	varis_ptr = internal::save_varis(varis_ptr, ts_[next_ts_index_]);
+	*partials_ptr = dy_dt[j];
+	partials_ptr++;
+	// dy[j]_dcurrent_t
       }
 
-      yt.emplace_back(ops_partials.build(coupled_state[j]));
+      yt.emplace_back(new precomputed_gradients_vari(coupled_state[j], total_vars, varis, partials));
     }
 
     y_.emplace_back(yt);
     next_ts_index_++;
   }
+
+  template<bool return_type_is_var = is_var<ReturnType>::value>
+  std::enable_if_t<not return_type_is_var>
+  operator()(const std::vector<double>& coupled_state, double t) {
+    y_.emplace_back(coupled_state);
+  }
 };
 
 }  // namespace math
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index e65beb9548f..a5761b5b973 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -1,12 +1,11 @@
 #ifndef STAN_MATH_REV_FUNCTOR_COUPLED_ODE_SYSTEM_HPP
 #define STAN_MATH_REV_FUNCTOR_COUPLED_ODE_SYSTEM_HPP
 
+#include <stan/math/rev/fun/value_of.hpp>
+#include <stan/math/rev/functor/cvodes_utils.hpp>
 #include <stan/math/rev/meta.hpp>
-#include <stan/math/rev/fun/value_of_rec.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
-#include <stan/math/prim/functor/coupled_ode_system.hpp>
 #include <stdexcept>
 #include <ostream>
 #include <vector>
@@ -14,334 +13,6 @@
 namespace stan {
 namespace math {
 
-/**
- * The <code>coupled_ode_system</code> template specialization
- * for known initial values and unknown parameters.
- *
- * <p>This coupled ode system has N + N * M states where N is the size of
- * the base ode system and M is the number of parameters.
- *
- * <p>For the coupled ode system, the first N states are the base
- * system's states: \f$ \frac{d x_n}{dt} \f$.
- *
- * <p>The next M states correspond to the sensitivities of the
- * parameters with respect to the first base system equation:
- * \f[
- *  \frac{d x_{N + m}}{dt}
- *  = \frac{d}{dt} \frac{\partial x_1}{\partial \theta_m}
- * \f]
- * for \f$ m \in {1, \ldots, M} \f$].
- *
- * <p> The next M states correspond to the sensitivites with respect
- * to the second base system equation, and so on through the last base
- * system equation.
- *
- * <p>Note: Calculating the sensitivity system requires the Jacobian
- * of the base ODE RHS wrt to the parameters theta. The parameter
- * vector theta is constant for successive calls to the exposed
- * operator(). For this reason, the parameter vector theta is copied
- * upon construction onto the nochain var autodiff tape which is used
- * in the the nested autodiff performed in the operator() of this
- * adaptor. Doing so reduces the size of the nested autodiff and
- * speeds up autodiff. As a side effect, the parameter vector theta
- * will remain on the nochain autodiff part of the autodiff tape being
- * in use even after destruction of the given instance. Moreover, the
- * adjoint zeroing for the nested system does not cover the theta
- * parameter vector part of the nochain autodiff tape and is therefore
- * set to zero using a dedicated loop.
- *
- * @tparam F base ode system functor. Must provide
- *   <code>operator()(double t, std::vector<double> y, std::vector<var> theta,
- *          std::vector<double> x, std::vector<int>x_int, std::ostream*
- * msgs)</code>
- */
-template <typename F>
-struct coupled_ode_system<F, double, var> {
-  const F& f_;
-  const std::vector<double>& y0_dbl_;
-  const std::vector<var>& theta_;
-  std::vector<var> theta_nochain_;
-  const std::vector<double>& x_;
-  const std::vector<int>& x_int_;
-  const size_t N_;
-  const size_t M_;
-  const size_t size_;
-  std::ostream* msgs_;
-
-  /**
-   * Construct a coupled ode system from the base system function,
-   * initial state of the base system, parameters, and a stream for
-   * messages.
-   *
-   * @param[in] f the base ODE system functor
-   * @param[in] y0 the initial state of the base ode
-   * @param[in] theta parameters of the base ode
-   * @param[in] x real data
-   * @param[in] x_int integer data
-   * @param[in, out] msgs stream for messages
-   */
-  coupled_ode_system(const F& f, const std::vector<double>& y0,
-                     const std::vector<var>& theta,
-                     const std::vector<double>& x,
-                     const std::vector<int>& x_int, std::ostream* msgs)
-      : f_(f),
-        y0_dbl_(y0),
-        theta_(theta),
-        x_(x),
-        x_int_(x_int),
-        N_(y0.size()),
-        M_(theta.size()),
-        size_(N_ + N_ * M_),
-        msgs_(msgs) {
-    for (const var& p : theta) {
-      theta_nochain_.emplace_back(var(new vari(p.val(), false)));
-    }
-  }
-
-  /**
-   * Calculates the derivative of the coupled ode system with respect
-   * to time.
-   *
-   * This method uses nested autodiff and is not thread safe.
-   *
-   * @param[in] z state of the coupled ode system; this must be size
-   *   <code>size()</code>
-   * @param[out] dz_dt a vector of size <code>size()</code> with the
-   *    derivatives of the coupled system with respect to time
-   * @param[in] t time
-   * @throw exception if the base ode function does not return the
-   *    expected number of derivatives, N.
-   */
-  void operator()(const std::vector<double>& z, std::vector<double>& dz_dt,
-                  double t) const {
-    using std::vector;
-
-    try {
-      start_nested();
-
-      const vector<var> y_vars(z.begin(), z.begin() + N_);
-
-      vector<var> dy_dt_vars = f_(t, y_vars, theta_nochain_, x_, x_int_, msgs_);
-
-      check_size_match("coupled_ode_system", "dz_dt", dy_dt_vars.size(),
-                       "states", N_);
-
-      for (size_t i = 0; i < N_; i++) {
-        dz_dt[i] = dy_dt_vars[i].val();
-        dy_dt_vars[i].grad();
-
-        for (size_t j = 0; j < M_; j++) {
-          // orders derivatives by equation (i.e. if there are 2 eqns
-          // (y1, y2) and 2 parameters (a, b), dy_dt will be ordered as:
-          // dy1_dt, dy2_dt, dy1_da, dy2_da, dy1_db, dy2_db
-          double temp_deriv = theta_nochain_[j].adj();
-          const size_t offset = N_ + N_ * j;
-          for (size_t k = 0; k < N_; k++) {
-            temp_deriv += z[offset + k] * y_vars[k].adj();
-          }
-
-          dz_dt[offset + i] = temp_deriv;
-        }
-
-        set_zero_all_adjoints_nested();
-        // Parameters stored on the outer (non-nested) nochain stack are not
-        // reset to zero by the last call. This is done as a separate step here.
-        // See efficiency note above on template specalization for more details
-        // on this.
-        for (size_t j = 0; j < M_; ++j) {
-          theta_nochain_[j].vi_->set_zero_adjoint();
-        }
-      }
-    } catch (const std::exception& e) {
-      recover_memory_nested();
-      throw;
-    }
-    recover_memory_nested();
-  }
-
-  /**
-   * Returns the size of the coupled system.
-   *
-   * @return size of the coupled system.
-   */
-  size_t size() const { return size_; }
-
-  /**
-   * Returns the initial state of the coupled system.
-   *
-   * The initial state of the coupled ode system is the same
-   * as the base ode system. This is because the initial values
-   * are known.
-   *
-   * There are N + N * M coupled states, where N is the number of base
-   * ode system states and M is the number of parameters. The first N
-   * correspond to the initial values provided. The next N * M states
-   * are all 0.
-   *
-   * @return the initial condition of the coupled system, a vector of
-   *   size N + N * M.
-   */
-  std::vector<double> initial_state() const {
-    std::vector<double> state(size_, 0.0);
-    for (size_t n = 0; n < N_; n++) {
-      state[n] = y0_dbl_[n];
-    }
-    return state;
-  }
-};
-
-/**
- * The <code>coupled_ode_system</code> template specialization
- * for unknown initial values and known parameters.
- *
- * <p>This coupled ode system has N + N * N states where N is the size
- * of the base ode system.
- *
- * <p>For the coupled ode system, the first N states are the base
- * system's states: \f$ \frac{d x_n}{dt} \f$.
- *
- * <p>The next N states correspond to the sensitivities of the
- * initial conditions with respect to the first base system equation:
- * \f[
- *  \frac{d x_{N + n}}{dt}
- *  = \frac{d}{dt} \frac{\partial x_1}{\partial y0_m}
- * \f]
- * for \f$ n \in {1, \ldots, N} \f$].
- *
- * <p> The next N states correspond to the sensitivites with respect
- * to the second base system equation, and so on through the last base
- * system equation.
- *
- * @tparam F base ode system functor. Must provide
- *   <code>operator()(double t, std::vector<var> y, std::vector<double> theta,
- *          std::vector<double> x, std::vector<int>x_int, std::ostream*
- * msgs)</code>
- */
-template <typename F>
-struct coupled_ode_system<F, var, double> {
-  const F& f_;
-  const std::vector<var>& y0_;
-  const std::vector<double>& theta_dbl_;
-  const std::vector<double>& x_;
-  const std::vector<int>& x_int_;
-  std::ostream* msgs_;
-  const size_t N_;
-  const size_t M_;
-  const size_t size_;
-
-  /**
-   * Construct a coupled ode system from the base system function,
-   * initial state of the base system, parameters, and a stream for
-   * messages.
-   *
-   * @param[in] f the base ODE system functor
-   * @param[in] y0 the initial state of the base ode
-   * @param[in] theta parameters of the base ode
-   * @param[in] x real data
-   * @param[in] x_int integer data
-   * @param[in, out] msgs stream for messages
-   */
-  coupled_ode_system(const F& f, const std::vector<var>& y0,
-                     const std::vector<double>& theta,
-                     const std::vector<double>& x,
-                     const std::vector<int>& x_int, std::ostream* msgs)
-      : f_(f),
-        y0_(y0),
-        theta_dbl_(theta),
-        x_(x),
-        x_int_(x_int),
-        msgs_(msgs),
-        N_(y0.size()),
-        M_(theta.size()),
-        size_(N_ + N_ * N_) {}
-
-  /**
-   * Calculates the derivative of the coupled ode system with respect
-   * to time.
-   *
-   * This method uses nested autodiff and is not thread safe.
-   *
-   * @param[in] z state of the coupled ode syste; this must be
-   *   size <code>size()</code>
-   * @param[out] dz_dt a vector of length size() with the
-   *   derivatives of the coupled system with respect to time
-   * @param[in] t time
-   * @throw exception if the base ode function does not return the
-   *    expected number of derivatives, N.
-   */
-  void operator()(const std::vector<double>& z, std::vector<double>& dz_dt,
-                  double t) const {
-    using std::vector;
-
-    try {
-      start_nested();
-
-      const vector<var> y_vars(z.begin(), z.begin() + N_);
-
-      vector<var> dy_dt_vars = f_(t, y_vars, theta_dbl_, x_, x_int_, msgs_);
-
-      check_size_match("coupled_ode_system", "dz_dt", dy_dt_vars.size(),
-                       "states", N_);
-
-      for (size_t i = 0; i < N_; i++) {
-        dz_dt[i] = dy_dt_vars[i].val();
-        dy_dt_vars[i].grad();
-
-        for (size_t j = 0; j < N_; j++) {
-          // orders derivatives by equation (i.e. if there are 2 eqns
-          // (y1, y2) and 2 initial conditions (y0_a, y0_b), dy_dt will be
-          // ordered as: dy1_dt, dy2_dt, dy1_d{y0_a}, dy2_d{y0_a}, dy1_d{y0_b},
-          // dy2_d{y0_b}
-          double temp_deriv = 0;
-          const size_t offset = N_ + N_ * j;
-          for (size_t k = 0; k < N_; k++) {
-            temp_deriv += z[offset + k] * y_vars[k].adj();
-          }
-
-          dz_dt[offset + i] = temp_deriv;
-        }
-
-        set_zero_all_adjoints_nested();
-      }
-    } catch (const std::exception& e) {
-      recover_memory_nested();
-      throw;
-    }
-    recover_memory_nested();
-  }
-
-  /**
-   * Returns the size of the coupled system.
-   *
-   * @return size of the coupled system.
-   */
-  size_t size() const { return size_; }
-
-  /**
-   * Returns the initial state of the coupled system.
-   *
-   * <p>Because the starting state is unknown, the coupled system
-   * incorporates the initial conditions as parameters.  At the initial
-   * time the Jacobian of the integrated function is the identity matrix.
-   *
-   * @return the initial condition of the coupled system.
-   *   This is a vector of length size() where the first N values are
-   *   the initial condition of the base ODE and the remainder
-   *   correspond to the identity matrix which is the Jacobian of the
-   *   integrated function at the initial time-point.
-   */
-  std::vector<double> initial_state() const {
-    std::vector<double> initial(size_, 0.0);
-    for (size_t i = 0; i < N_; i++) {
-      initial[i] = value_of(y0_[i]);
-    }
-    for (size_t i = 0; i < N_; i++) {
-      initial[N_ + i * N_ + i] = 1.0;
-    }
-    return initial;
-  }
-};
-
 /**
  * The <code>coupled_ode_system</code> template specialization
  * for unknown initial values and unknown parameters.
@@ -390,17 +61,16 @@ struct coupled_ode_system<F, var, double> {
  *          std::vector<double> x, std::vector<int>x_int, std::ostream*
  * msgs)</code>
  */
-template <typename F>
-struct coupled_ode_system<F, var, var> {
+template <typename T1, typename F, typename... Args>
+struct coupled_ode_system {
+  using ReturnType = return_type_t<T1, Args...>;
+
   const F& f_;
-  const std::vector<var>& y0_;
-  const std::vector<var>& theta_;
-  std::vector<var> theta_nochain_;
-  const std::vector<double>& x_;
-  const std::vector<int>& x_int_;
+  const std::vector<T1>& y0_;
+  std::tuple<const Args&...> args_tuple_;
+  const size_t y0_vars_;
+  const size_t args_vars_;
   const size_t N_;
-  const size_t M_;
-  const size_t size_;
   std::ostream* msgs_;
 
   /**
@@ -415,22 +85,15 @@ struct coupled_ode_system<F, var, var> {
    * @param[in] x_int integer data
    * @param[in, out] msgs stream for messages
    */
-  coupled_ode_system(const F& f, const std::vector<var>& y0,
-                     const std::vector<var>& theta,
-                     const std::vector<double>& x,
-                     const std::vector<int>& x_int, std::ostream* msgs)
+  coupled_ode_system(const F& f, const std::vector<T1>& y0,
+                     const Args&... args, std::ostream* msgs)
       : f_(f),
         y0_(y0),
-        theta_(theta),
-        x_(x),
-        x_int_(x_int),
+	args_tuple_(args...),
+	y0_vars_(internal::count_vars(y0_)),
+	args_vars_(internal::count_vars(args...)),
         N_(y0.size()),
-        M_(theta.size()),
-        size_(N_ + N_ * (N_ + M_)),
         msgs_(msgs) {
-    for (const var& p : theta) {
-      theta_nochain_.emplace_back(var(new vari(p.val(), false)));
-    }
   }
 
   /**
@@ -447,7 +110,9 @@ struct coupled_ode_system<F, var, var> {
    * @throw exception if the base ode function does not return the
    *    expected number of derivatives, N.
    */
-  void operator()(const std::vector<double>& z, std::vector<double>& dz_dt,
+  template<bool return_type_is_var = is_var<ReturnType>::value>
+  std::enable_if_t<return_type_is_var>
+  operator()(const std::vector<double>& z, std::vector<double>& dz_dt,
                   double t) const {
     using std::vector;
 
@@ -455,8 +120,13 @@ struct coupled_ode_system<F, var, var> {
       start_nested();
 
       const vector<var> y_vars(z.begin(), z.begin() + N_);
+      auto local_args_tuple = apply([&](const Args&... args) {
+	  return std::tuple<decltype(internal::deep_copy(args))...>(internal::deep_copy(args)...);
+	}, args_tuple_);
 
-      vector<var> dy_dt_vars = f_(t, y_vars, theta_nochain_, x_, x_int_, msgs_);
+      vector<var> dy_dt_vars = apply([&](const Args&... args) {
+	  return f_(t, y_vars, args..., msgs_);
+	}, local_args_tuple);
 
       check_size_match("coupled_ode_system", "dz_dt", dy_dt_vars.size(),
                        "states", N_);
@@ -465,37 +135,33 @@ struct coupled_ode_system<F, var, var> {
         dz_dt[i] = dy_dt_vars[i].val();
         dy_dt_vars[i].grad();
 
-        for (size_t j = 0; j < N_; j++) {
+        for (size_t j = 0; j < y0_vars_; j++) {
           // orders derivatives by equation (i.e. if there are 2 eqns
           // (y1, y2) and 2 parameters (a, b), dy_dt will be ordered as:
           // dy1_dt, dy2_dt, dy1_da, dy2_da, dy1_db, dy2_db
           double temp_deriv = 0;
           const size_t offset = N_ + N_ * j;
           for (size_t k = 0; k < N_; k++) {
-            temp_deriv += z[offset + k] * y_vars[k].adj();
+            temp_deriv += z[N_ + N_ * j + k] * y_vars[k].adj();
           }
 
-          dz_dt[offset + i] = temp_deriv;
+          dz_dt[N_ + N_ * j + i] = temp_deriv;
         }
 
-        for (size_t j = 0; j < M_; j++) {
-          double temp_deriv = theta_nochain_[j].adj();
-          const size_t offset = N_ + N_ * N_ + N_ * j;
+	Eigen::VectorXd args_adjoints = Eigen::VectorXd::Zero(args_vars_);
+	apply([&](const Args&... args) {
+	    internal::accumulate_adjoints(args_adjoints.data(), args...);
+	  }, local_args_tuple);
+        for (size_t j = 0; j < args_vars_; j++) {
+          double temp_deriv = args_adjoints(j);
           for (size_t k = 0; k < N_; k++) {
-            temp_deriv += z[offset + k] * y_vars[k].adj();
+            temp_deriv += z[N_ + N_ * y0_vars_ + N_ * j + k] * y_vars[k].adj();
           }
 
-          dz_dt[offset + i] = temp_deriv;
+          dz_dt[N_ + N_ * y0_vars_ + N_ * j + i] = temp_deriv;
         }
 
         set_zero_all_adjoints_nested();
-        // Parameters stored on the outer (non-nested) nochain stack are not
-        // reset to zero by the last call. This is done as a separate step here.
-        // See efficiency note above on template specalization for more details
-        // on this.
-        for (size_t j = 0; j < M_; ++j) {
-          theta_nochain_[j].vi_->set_zero_adjoint();
-        }
       }
     } catch (const std::exception& e) {
       recover_memory_nested();
@@ -504,12 +170,24 @@ struct coupled_ode_system<F, var, var> {
     recover_memory_nested();
   }
 
+  template<bool return_type_is_var = is_var<ReturnType>::value>
+  std::enable_if_t<not return_type_is_var>
+  operator()(const std::vector<double>& y, std::vector<double>& dy_dt,
+                  double t) const {
+    dy_dt = apply([&](const Args&... args) {
+	return f_(t, y, args..., msgs_);
+      }, args_tuple_);
+
+    check_size_match("coupled_ode_system", "y", y.size(), "dy_dt",
+                     dy_dt.size());
+  }
+
   /**
    * Returns the size of the coupled system.
    *
    * @return size of the coupled system.
    */
-  size_t size() const { return size_; }
+  size_t size() const { return N_ + N_ * y0_vars_ + N_ * args_vars_; }
 
   /**
    * Returns the initial state of the coupled system.
@@ -530,11 +208,11 @@ struct coupled_ode_system<F, var, var> {
    *   parameters at the initial time-point, which is zero.
    */
   std::vector<double> initial_state() const {
-    std::vector<double> initial(size_, 0.0);
+    std::vector<double> initial(size(), 0.0);
     for (size_t i = 0; i < N_; i++) {
       initial[i] = value_of(y0_[i]);
     }
-    for (size_t i = 0; i < N_; i++) {
+    for (size_t i = 0; i < y0_vars_; i++) {
       initial[N_ + i * N_ + i] = 1.0;
     }
     return initial;
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 3d4fb4f9d37..736a018e947 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -2,13 +2,12 @@
 #define STAN_MATH_REV_FUNCTOR_INTEGRATE_ODE_CVODES_HPP
 
 #include <stan/math/rev/meta.hpp>
-#include <stan/math/rev/functor/coupled_ode_system.hpp>
 #include <stan/math/rev/functor/cvodes_utils.hpp>
+#include <stan/math/rev/functor/coupled_ode_system.hpp>
 #include <stan/math/rev/functor/cvodes_ode_data.hpp>
+#include <stan/math/rev/functor/coupled_ode_observer.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/value_of.hpp>
-#include <stan/math/prim/functor/coupled_ode_observer.hpp>
-#include <stan/math/prim/functor/coupled_ode_system.hpp>
 #include <cvodes/cvodes.h>
 #include <sunlinsol/sunlinsol_dense.h>
 #include <algorithm>
@@ -69,18 +68,16 @@ class cvodes_integrator {
    * @return a vector of states, each state being a vector of the
    * same size as the state variable, corresponding to a time in ts.
    */
-  template <typename F, typename T_initial, typename T_param, typename T_t0,
-            typename T_ts>
+  template <typename... Args, typename F, typename T_initial,
+	    typename T_t0, typename T_ts>
   std::vector<std::vector<
-      typename stan::return_type<T_initial, T_param, T_t0, T_ts>::type>>
+		typename stan::return_type<T_initial, T_t0, T_ts, Args...>::type>>
   integrate(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
-            const std::vector<T_ts>& ts, const std::vector<T_param>& theta,
-            const std::vector<double>& x, const std::vector<int>& x_int,
+            const std::vector<T_ts>& ts, const Args&... args,
             std::ostream* msgs, double relative_tolerance,
             double absolute_tolerance,
             long int max_num_steps) {  // NOLINT(runtime/int)
     using initial_var = stan::is_var<T_initial>;
-    using param_var = stan::is_var<T_param>;
 
     const char* fun = "integrate_ode_cvodes";
 
@@ -90,8 +87,10 @@ class cvodes_integrator {
     check_finite(fun, "initial state", y0);
     check_finite(fun, "initial time", t0_dbl);
     check_finite(fun, "times", ts_dbl);
-    check_finite(fun, "parameter vector", theta);
-    check_finite(fun, "continuous data", x);
+
+    // Code from: https://stackoverflow.com/a/17340003 . Should probably do something better
+    std::vector<int> unused_temp{ 0, (check_finite(fun, "ode parameters and data", args), 0)... };
+
     check_nonzero_size(fun, "times", ts);
     check_nonzero_size(fun, "initial state", y0);
     check_ordered(fun, "times", ts_dbl);
@@ -109,12 +108,13 @@ class cvodes_integrator {
                        "", ", must be greater than 0");
     }
 
-    const size_t N = y0.size();
-    const size_t M = theta.size();
-    const size_t S = (initial_var::value ? N : 0) + (param_var::value ? M : 0);
 
-    using ode_data = cvodes_ode_data<F, T_initial, T_param>;
-    ode_data cvodes_data(f, y0, theta, x, x_int, msgs);
+    const size_t y0_vars = internal::count_vars(y0);
+    const size_t args_vars = internal::count_vars(args...);
+    const size_t S = y0_vars + args_vars;
+
+    using ode_data = cvodes_ode_data<F, T_initial, Args...>;
+    ode_data cvodes_data(f, y0, args..., msgs);
 
     void* cvodes_mem = CVodeCreate(Lmm);
     if (cvodes_mem == nullptr) {
@@ -123,11 +123,10 @@ class cvodes_integrator {
 
     const size_t coupled_size = cvodes_data.coupled_ode_.size();
 
-    std::vector<std::vector<
-        typename stan::return_type<T_initial, T_param, T_t0, T_ts>::type>>
-        y;
-    coupled_ode_observer<F, T_initial, T_param, T_t0, T_ts> observer(
-        f, y0, theta, t0, ts, x, x_int, msgs, y);
+    using return_t = return_type_t<T_initial, T_t0, T_ts, Args...>;
+    
+    std::vector<std::vector<return_t>> y;
+    coupled_ode_observer<T_initial, T_t0, T_ts, F, Args...> observer(f, y0, t0, ts, args..., msgs, y);
 
     try {
       check_flag_sundials(CVodeInit(cvodes_mem, &ode_data::cv_rhs, t0_dbl,
diff --git a/stan/math/rev/functor/cvodes_ode_data.hpp b/stan/math/rev/functor/cvodes_ode_data.hpp
index 2036c5f5d4e..aa7d823315c 100644
--- a/stan/math/rev/functor/cvodes_ode_data.hpp
+++ b/stan/math/rev/functor/cvodes_ode_data.hpp
@@ -3,7 +3,6 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/functor/coupled_ode_system.hpp>
-#include <stan/math/prim/functor/coupled_ode_system.hpp>
 #include <cvodes/cvodes.h>
 #include <sunmatrix/sunmatrix_dense.h>
 #include <sunlinsol/sunlinsol_dense.h>
@@ -22,25 +21,20 @@ namespace math {
  * @tparam T_initial type of initial values
  * @tparam T_param type of parameters
  */
-template <typename F, typename T_initial, typename T_param>
+template <typename F, typename T_initial, typename... Args>
 class cvodes_ode_data {
   const F& f_;
   const std::vector<T_initial>& y0_;
-  const std::vector<T_param>& theta_;
-  const std::vector<double> theta_dbl_;
+  std::tuple<const Args&...> args_tuple_;
   const size_t N_;
-  const size_t M_;
-  const std::vector<double>& x_;
-  const std::vector<int>& x_int_;
   std::ostream* msgs_;
+  const size_t y0_vars_;
+  const size_t args_vars_;
   const size_t S_;
 
-  using ode_data = cvodes_ode_data<F, T_initial, T_param>;
-  using initial_var = stan::is_var<T_initial>;
-  using param_var = stan::is_var<T_param>;
-
+  using ode_data = cvodes_ode_data<F, T_initial, Args...>;
  public:
-  const coupled_ode_system<F, T_initial, T_param> coupled_ode_;
+  const coupled_ode_system<T_initial, F, Args...> coupled_ode_;
   std::vector<double> coupled_state_;
   N_Vector nv_state_;
   N_Vector* nv_state_sens_;
@@ -69,21 +63,19 @@ class cvodes_ode_data {
    * @param[in] x_int integer data vector for the ODE.
    * @param[in] msgs stream to which messages are printed.
    */
-  cvodes_ode_data(const F& f, const std::vector<T_initial>& y0,
-                  const std::vector<T_param>& theta,
-                  const std::vector<double>& x, const std::vector<int>& x_int,
+  cvodes_ode_data(const F& f,
+		  const std::vector<T_initial>& y0,
+		  const Args&... args,
                   std::ostream* msgs)
       : f_(f),
         y0_(y0),
-        theta_(theta),
-        theta_dbl_(value_of(theta)),
+	args_tuple_(args...),
         N_(y0.size()),
-        M_(theta.size()),
-        x_(x),
-        x_int_(x_int),
         msgs_(msgs),
-        S_((initial_var::value ? N_ : 0) + (param_var::value ? M_ : 0)),
-        coupled_ode_(f, y0, theta, x, x_int, msgs),
+	y0_vars_(internal::count_vars(y0_)),
+	args_vars_(internal::count_vars(args...)),
+	S_(y0_vars_ + args_vars_),
+        coupled_ode_(f, y0, args..., msgs),
         coupled_state_(coupled_ode_.initial_state()),
         nv_state_(N_VMake_Serial(N_, &coupled_state_[0])),
         nv_state_sens_(nullptr),
@@ -148,8 +140,9 @@ class cvodes_ode_data {
    */
   inline void rhs(double t, const double y[], double dy_dt[]) const {
     const std::vector<double> y_vec(y, y + N_);
-    const std::vector<double>& dy_dt_vec
-        = f_(t, y_vec, theta_dbl_, x_, x_int_, msgs_);
+    std::vector<double> dy_dt_vec = apply([&](const Args&... args) {
+	return f_(t, y_vec, value_of(args)..., msgs_);
+      }, args_tuple_);
     check_size_match("cvodes_ode_data", "dz_dt", dy_dt_vec.size(), "states",
                      N_);
     std::move(dy_dt_vec.begin(), dy_dt_vec.end(), dy_dt);
@@ -165,8 +158,9 @@ class cvodes_ode_data {
   inline int jacobian_states(double t, const double y[], SUNMatrix J) const {
     start_nested();
     const std::vector<var> y_vec_var(y, y + N_);
-    coupled_ode_system<F, var, double> ode_jacobian(f_, y_vec_var, theta_dbl_,
-                                                    x_, x_int_, msgs_);
+    auto ode_jacobian = apply([&](const Args&... args) {
+	return coupled_ode_system<var, F, decltype(value_of(args))...>(f_, y_vec_var, value_of(args)..., msgs_);
+      }, args_tuple_);
     std::vector<double>&& jacobian_y = std::vector<double>(ode_jacobian.size());
     ode_jacobian(ode_jacobian.initial_state(), jacobian_y, t);
     std::move(jacobian_y.begin() + N_, jacobian_y.end(), SM_DATA_D(J));
diff --git a/stan/math/rev/functor/integrate_ode_bdf.hpp b/stan/math/rev/functor/integrate_ode_bdf.hpp
index a86065c9379..f6052fbc6a0 100644
--- a/stan/math/rev/functor/integrate_ode_bdf.hpp
+++ b/stan/math/rev/functor/integrate_ode_bdf.hpp
@@ -22,7 +22,9 @@ integrate_ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
                   double absolute_tolerance = 1e-10,
                   long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
   stan::math::cvodes_integrator<CV_BDF> integrator;
-  return integrator.integrate(f, y0, t0, ts, theta, x, x_int, msgs,
+  return integrator.integrate<std::vector<T_param>,
+			      std::vector<double>,
+			      std::vector<int>>(f, y0, t0, ts, theta, x, x_int, msgs,
                               relative_tolerance, absolute_tolerance,
                               max_num_steps);
 }
diff --git a/stan/math/prim/functor/integrate_ode_rk45.hpp b/stan/math/rev/functor/integrate_ode_rk45.hpp
similarity index 82%
rename from stan/math/prim/functor/integrate_ode_rk45.hpp
rename to stan/math/rev/functor/integrate_ode_rk45.hpp
index f920b65d5a7..aac4e36693e 100644
--- a/stan/math/prim/functor/integrate_ode_rk45.hpp
+++ b/stan/math/rev/functor/integrate_ode_rk45.hpp
@@ -1,11 +1,12 @@
-#ifndef STAN_MATH_PRIM_FUNCTOR_INTEGRATE_ODE_RK45_HPP
-#define STAN_MATH_PRIM_FUNCTOR_INTEGRATE_ODE_RK45_HPP
+#ifndef STAN_MATH_REV_FUNCTOR_INTEGRATE_ODE_RK45_HPP
+#define STAN_MATH_REV_FUNCTOR_INTEGRATE_ODE_RK45_HPP
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/prim/functor/coupled_ode_system.hpp>
-#include <stan/math/prim/functor/coupled_ode_observer.hpp>
+#include <stan/math/rev/functor/coupled_ode_system.hpp>
+#include <stan/math/rev/functor/coupled_ode_observer.hpp>
 #include <stan/math/prim/fun/value_of.hpp>
+#include <stan/math/prim/functor/apply.hpp>
 #include <boost/version.hpp>
 #if BOOST_VERSION == 106400
 #include <boost/serialization/array_wrapper.hpp>
@@ -66,26 +67,30 @@ namespace math {
  * @return a vector of states, each state being a vector of the
  * same size as the state variable, corresponding to a time in ts.
  */
-template <typename F, typename T1, typename T2, typename T_t0, typename T_ts>
-std::vector<std::vector<return_type_t<T1, T2, T_t0, T_ts>>> integrate_ode_rk45(
+
+template <typename ...Args, typename F, typename T1, typename T_t0, typename T_ts>
+std::vector<std::vector<return_type_t<T1, T_t0, T_ts, Args...>>> integrate_ode_rk45(
     const F& f, const std::vector<T1>& y0, const T_t0& t0,
-    const std::vector<T_ts>& ts, const std::vector<T2>& theta,
-    const std::vector<double>& x, const std::vector<int>& x_int,
-    std::ostream* msgs = nullptr, double relative_tolerance = 1e-6,
-    double absolute_tolerance = 1e-6, int max_num_steps = 1E6) {
+    const std::vector<T_ts>& ts,
+    const Args&... args,
+    std::ostream* msgs = nullptr,
+    double relative_tolerance = 1e-6,
+    double absolute_tolerance = 1e-6,
+    int max_num_steps = 1e6) {
   using boost::numeric::odeint::integrate_times;
   using boost::numeric::odeint::make_dense_output;
   using boost::numeric::odeint::max_step_checker;
   using boost::numeric::odeint::runge_kutta_dopri5;
-
+  
   const double t0_dbl = value_of(t0);
   const std::vector<double> ts_dbl = value_of(ts);
 
   check_finite("integrate_ode_rk45", "initial state", y0);
   check_finite("integrate_ode_rk45", "initial time", t0_dbl);
   check_finite("integrate_ode_rk45", "times", ts_dbl);
-  check_finite("integrate_ode_rk45", "parameter vector", theta);
-  check_finite("integrate_ode_rk45", "continuous data", x);
+
+  // Code from: https://stackoverflow.com/a/17340003 . Should probably do something better
+  std::vector<int> unused_temp{ 0, (check_finite("integrate_ode_rk45", "ode parameters and data", args), 0)... };
 
   check_nonzero_size("integrate_ode_rk45", "initial state", y0);
   check_nonzero_size("integrate_ode_rk45", "times", ts_dbl);
@@ -105,17 +110,17 @@ std::vector<std::vector<return_type_t<T1, T2, T_t0, T_ts>>> integrate_ode_rk45(
                      ", must be greater than 0");
   }
 
+  using return_t = return_type_t<T1, T_t0, T_ts, Args...>;
   // creates basic or coupled system by template specializations
-  coupled_ode_system<F, T1, T2> coupled_system(f, y0, theta, x, x_int, msgs);
+  coupled_ode_system<T1, F, Args...> coupled_system(f, y0, args..., msgs);
 
   // first time in the vector must be time of initial state
   std::vector<double> ts_vec(ts.size() + 1);
   ts_vec[0] = t0_dbl;
   std::copy(ts_dbl.begin(), ts_dbl.end(), ts_vec.begin() + 1);
 
-  std::vector<std::vector<return_type_t<T1, T2, T_t0, T_ts>>> y;
-  coupled_ode_observer<F, T1, T2, T_t0, T_ts> observer(f, y0, theta, t0, ts, x,
-                                                       x_int, msgs, y);
+  std::vector<std::vector<return_t>> y;
+  coupled_ode_observer<T1, T_t0, T_ts, F, Args...> observer(f, y0, t0, ts, args..., msgs, y);
   bool observer_initial_recorded = false;
 
   // avoid recording of the initial state which is included by the
diff --git a/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp
index 6b85d0d2576..137827effbf 100644
--- a/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp
@@ -206,7 +206,7 @@ TEST(StanMathOde_integrate_ode_bdf, error_conditions_nan) {
   theta_bad[0] = nan;
   EXPECT_THROW_MSG(integrate_ode_bdf(harm_osc, y0, t0, ts, theta_bad, x, x_int,
                                      0, 1e-8, 1e-10, 1e6),
-                   std::domain_error, "parameter vector");
+                   std::domain_error, "ode parameters and data");
   EXPECT_THROW_MSG(integrate_ode_bdf(harm_osc, y0, t0, ts, theta_bad, x, x_int,
                                      0, 1e-8, 1e-10, 1e6),
                    std::domain_error, expected_is_nan.str());
@@ -216,7 +216,7 @@ TEST(StanMathOde_integrate_ode_bdf, error_conditions_nan) {
     x_bad[0] = nan;
     EXPECT_THROW_MSG(integrate_ode_bdf(harm_osc, y0, t0, ts, theta, x_bad,
                                        x_int, 0, 1e-8, 1e-10, 1e6),
-                     std::domain_error, "continuous data");
+                     std::domain_error, "ode parameters and data");
     EXPECT_THROW_MSG(integrate_ode_bdf(harm_osc, y0, t0, ts, theta, x_bad,
                                        x_int, 0, 1e-8, 1e-10, 1e6),
                      std::domain_error, expected_is_nan.str());
@@ -303,14 +303,14 @@ TEST(StanMathOde_integrate_ode_bdf, error_conditions_inf) {
   theta_bad[0] = inf;
   EXPECT_THROW_MSG(integrate_ode_bdf(harm_osc, y0, t0, ts, theta_bad, x, x_int,
                                      0, 1e-8, 1e-10, 1e6),
-                   std::domain_error, "parameter vector");
+                   std::domain_error, "ode parameters and data");
   EXPECT_THROW_MSG(integrate_ode_bdf(harm_osc, y0, t0, ts, theta_bad, x, x_int,
                                      0, 1e-8, 1e-10, 1e6),
                    std::domain_error, expected_is_inf.str());
   theta_bad[0] = -inf;
   EXPECT_THROW_MSG(integrate_ode_bdf(harm_osc, y0, t0, ts, theta_bad, x, x_int,
                                      0, 1e-8, 1e-10, 1e6),
-                   std::domain_error, "parameter vector");
+                   std::domain_error, "ode parameters and data");
   EXPECT_THROW_MSG(integrate_ode_bdf(harm_osc, y0, t0, ts, theta_bad, x, x_int,
                                      0, 1e-8, 1e-10, 1e6),
                    std::domain_error, expected_is_neg_inf.str());
@@ -320,14 +320,14 @@ TEST(StanMathOde_integrate_ode_bdf, error_conditions_inf) {
     x_bad[0] = inf;
     EXPECT_THROW_MSG(integrate_ode_bdf(harm_osc, y0, t0, ts, theta, x_bad,
                                        x_int, 0, 1e-8, 1e-10, 1e6),
-                     std::domain_error, "continuous data");
+                     std::domain_error, "ode parameters and data");
     EXPECT_THROW_MSG(integrate_ode_bdf(harm_osc, y0, t0, ts, theta, x_bad,
                                        x_int, 0, 1e-8, 1e-10, 1e6),
                      std::domain_error, expected_is_inf.str());
     x_bad[0] = -inf;
     EXPECT_THROW_MSG(integrate_ode_bdf(harm_osc, y0, t0, ts, theta, x_bad,
                                        x_int, 0, 1e-8, 1e-10, 1e6),
-                     std::domain_error, "continuous data");
+                     std::domain_error, "ode parameters and data");
     EXPECT_THROW_MSG(integrate_ode_bdf(harm_osc, y0, t0, ts, theta, x_bad,
                                        x_int, 0, 1e-8, 1e-10, 1e6),
                      std::domain_error, expected_is_neg_inf.str());
@@ -361,3 +361,4 @@ TEST(StanMathOde_integrate_ode_bdf, error_conditions_bad_ode) {
                                      1e-8, 1e-10, 1e6),
                    std::invalid_argument, error_msg);
 }
+
diff --git a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
index 987f49a61ee..42065d3eeb1 100644
--- a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
@@ -53,7 +53,7 @@ void sho_finite_diff_test(double t0) {
   sho_value_test<harm_osc_ode_fun, var, double>(harm_osc, y0, t0, ts, theta, x,
                                                 x_int);
   sho_value_test<harm_osc_ode_fun, var, var>(harm_osc, y0, t0, ts, theta, x,
-                                             x_int);
+                                            x_int);
 }
 
 void sho_data_finite_diff_test(double t0) {
@@ -134,7 +134,7 @@ TEST(StanAgradRevOde_integrate_ode_bdf, harmonic_oscillator_error) {
   sho_error_test<double, var>(harm_osc, y0, t0, ts, theta, x, x_int, error_msg);
   sho_error_test<var, double>(harm_osc, y0, t0, ts, theta, x, x_int, error_msg);
   sho_error_test<var, var>(harm_osc, y0, t0, ts, theta, x, x_int, error_msg);
-}
+  }
 
 TEST(StanAgradRevOde_integrate_ode_bdf, lorenz_finite_diff) {
   lorenz_ode_fun lorenz;
@@ -304,3 +304,4 @@ TEST(StanAgradRevOde_integrate_ode_bdf, t0_as_param_AD) {
   res = integrate_ode_bdf(ode, y0v, t0v, ts, thetav, x, x_int);
   test_ad();
 }
+
diff --git a/test/unit/math/prim/functor/integrate_ode_rk45_test.cpp b/test/unit/math/rev/functor/integrate_ode_rk45_prim_test.cpp
similarity index 50%
rename from test/unit/math/prim/functor/integrate_ode_rk45_test.cpp
rename to test/unit/math/rev/functor/integrate_ode_rk45_prim_test.cpp
index 8f308675ea0..a72d02a356a 100644
--- a/test/unit/math/prim/functor/integrate_ode_rk45_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_rk45_prim_test.cpp
@@ -1,4 +1,4 @@
-#include <stan/math/prim.hpp>
+#include <stan/math/rev.hpp>
 #include <gtest/gtest.h>
 #include <boost/numeric/odeint.hpp>
 #include <test/unit/math/prim/functor/harmonic_oscillator.hpp>
@@ -9,21 +9,19 @@
 #include <vector>
 #include <limits>
 
-template <typename F>
+std::ostream* msgs = nullptr;
+
+template <typename F, typename... Args>
 void sho_death_test(F harm_osc, std::vector<double>& y0, double t0,
-                    std::vector<double>& ts, std::vector<double>& theta,
-                    std::vector<double>& x, std::vector<int>& x_int) {
-  EXPECT_DEATH(
-      stan::math::integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int),
-      "");
+                    std::vector<double>& ts, Args&... args) {
+  EXPECT_DEATH(stan::math::integrate_ode_rk45<Args...>(harm_osc, y0, t0, ts, args...), "");
 }
 
-template <typename F>
+template <typename F, typename... Args>
 void sho_value_test(F harm_osc, std::vector<double>& y0, double t0,
-                    std::vector<double>& ts, std::vector<double>& theta,
-                    std::vector<double>& x, std::vector<int>& x_int) {
+                    std::vector<double>& ts, Args&... args) {
   std::vector<std::vector<double> > ode_res_vd
-      = stan::math::integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int);
+    = stan::math::integrate_ode_rk45<Args...>(harm_osc, y0, t0, ts, args...);
   EXPECT_NEAR(0.995029, ode_res_vd[0][0], 1e-5);
   EXPECT_NEAR(-0.0990884, ode_res_vd[0][1], 1e-5);
 
@@ -101,54 +99,54 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions) {
   std::vector<double> x(3, 1);
   std::vector<int> x_int(2, 0);
 
-  ASSERT_NO_THROW(integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int));
+  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x, x_int)));
 
   std::vector<double> y0_bad;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
       std::invalid_argument, "initial state has size 0");
 
   double t0_bad = 2.0;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
       std::domain_error, "initial time is 2, but must be less than 0.1");
 
   std::vector<double> ts_bad;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
       std::invalid_argument, "times has size 0");
 
   ts_bad.push_back(3);
   ts_bad.push_back(1);
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
       std::domain_error, "times is not a valid ordered vector");
 
   std::vector<double> theta_bad;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
       std::out_of_range, "vector");
 
   std::vector<double> x_bad;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
       std::out_of_range, "vector");
 
   std::vector<int> x_int_bad;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int_bad),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x, x_int_bad)),
       std::out_of_range, "vector");
 
-  EXPECT_THROW_MSG(integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int, 0,
-                                      -1, 1e-6, 10),
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x, x_int, 0,
+												   -1, 1e-6, 10)),
                    std::invalid_argument, "relative_tolerance");
 
-  EXPECT_THROW_MSG(integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int, 0,
-                                      1e-6, -1, 10),
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x, x_int, 0,
+												   1e-6, -1, 10)),
                    std::invalid_argument, "absolute_tolerance");
 
-  EXPECT_THROW_MSG(integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int, 0,
-                                      1e-6, 1e-6, -1),
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x, x_int, 0,
+												  1e-6, 1e-6, -1)),
                    std::invalid_argument, "max_num_steps");
 }
 
@@ -172,7 +170,7 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions_nan) {
   std::vector<double> x(3, 1);
   std::vector<int> x_int(2, 0);
 
-  ASSERT_NO_THROW(integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int));
+  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x, x_int)));
 
   double nan = std::numeric_limits<double>::quiet_NaN();
   std::stringstream expected_is_nan;
@@ -181,46 +179,46 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions_nan) {
   std::vector<double> y0_bad = y0;
   y0_bad[0] = nan;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
       std::domain_error, "initial state");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
       std::domain_error, expected_is_nan.str());
 
   double t0_bad = nan;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
       std::domain_error, "initial time");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
       std::domain_error, expected_is_nan.str());
 
   std::vector<double> ts_bad = ts;
   ts_bad[0] = nan;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
       std::domain_error, "times");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
       std::domain_error, expected_is_nan.str());
 
   std::vector<double> theta_bad = theta;
   theta_bad[0] = nan;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int),
-      std::domain_error, "parameter vector");
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
+      std::domain_error, "parameters and data");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
       std::domain_error, expected_is_nan.str());
 
   if (x.size() > 0) {
     std::vector<double> x_bad = x;
     x_bad[0] = nan;
     EXPECT_THROW_MSG(
-        integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int),
-        std::domain_error, "continuous data");
+		     (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+        std::domain_error, "parameters and data");
     EXPECT_THROW_MSG(
-        integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int),
+		     (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
         std::domain_error, expected_is_nan.str());
   }
 }
@@ -249,88 +247,88 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions_inf) {
   std::vector<double> x(3, 1);
   std::vector<int> x_int(2, 0);
 
-  ASSERT_NO_THROW(integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int));
+  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x, x_int)));
 
   double inf = std::numeric_limits<double>::infinity();
   std::vector<double> y0_bad = y0;
   y0_bad[0] = inf;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
       std::domain_error, "initial state");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
       std::domain_error, expected_is_inf.str());
 
   y0_bad[0] = -inf;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
       std::domain_error, "initial state");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
       std::domain_error, expected_is_neg_inf.str());
 
   double t0_bad = inf;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
       std::domain_error, "initial time");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
       std::domain_error, expected_is_inf.str());
   t0_bad = -inf;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
       std::domain_error, "initial time");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
       std::domain_error, expected_is_neg_inf.str());
 
   std::vector<double> ts_bad = ts;
   ts_bad.push_back(inf);
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
       std::domain_error, "times");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
       std::domain_error, expected_is_inf.str());
   ts_bad[0] = -inf;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
       std::domain_error, "times");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
       std::domain_error, expected_is_neg_inf.str());
 
   std::vector<double> theta_bad = theta;
   theta_bad[0] = inf;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int),
-      std::domain_error, "parameter vector");
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
+      std::domain_error, "parameters and data");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
       std::domain_error, expected_is_inf.str());
   theta_bad[0] = -inf;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int),
-      std::domain_error, "parameter vector");
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
+      std::domain_error, "parameters and data");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int),
+		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
       std::domain_error, expected_is_neg_inf.str());
 
   if (x.size() > 0) {
     std::vector<double> x_bad = x;
     x_bad[0] = inf;
     EXPECT_THROW_MSG(
-        integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int),
-        std::domain_error, "continuous data");
+		     (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+        std::domain_error, "parameters and data");
     EXPECT_THROW_MSG(
-        integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int),
+		     (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
         std::domain_error, expected_is_inf.str());
     x_bad[0] = -inf;
     EXPECT_THROW_MSG(
-        integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int),
-        std::domain_error, "continuous data");
+		     (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+        std::domain_error, "parameters and data");
     EXPECT_THROW_MSG(
-        integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int),
+		     (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
         std::domain_error, expected_is_neg_inf.str());
   }
 }
diff --git a/test/unit/math/rev/functor/integrate_ode_rk45_test.cpp b/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
similarity index 75%
rename from test/unit/math/rev/functor/integrate_ode_rk45_test.cpp
rename to test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
index 5088970a020..487cdded308 100644
--- a/test/unit/math/rev/functor/integrate_ode_rk45_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
@@ -16,9 +16,10 @@ void sho_value_test(F harm_osc, std::vector<double>& y0, double t0,
   using stan::math::promote_scalar;
   using stan::math::var;
 
-  std::vector<std::vector<var>> ode_res_vd = stan::math::integrate_ode_rk45(
-      harm_osc, promote_scalar<T_y0>(y0), t0, ts,
-      promote_scalar<T_theta>(theta), x, x_int, 0);
+  std::vector<std::vector<var>> ode_res_vd = stan::math::integrate_ode_rk45
+    <std::vector<T_theta>, std::vector<double>, std::vector<int>>
+    (harm_osc, promote_scalar<T_y0>(y0), t0, ts,
+     promote_scalar<T_theta>(theta), x, x_int, 0);
   EXPECT_NEAR(0.995029, ode_res_vd[0][0].val(), 1e-5);
   EXPECT_NEAR(-0.0990884, ode_res_vd[0][1].val(), 1e-5);
 
@@ -139,7 +140,7 @@ TEST(StanAgradRevOde_integrate_ode_rk45, time_steps_as_param) {
   std::vector<std::vector<stan::math::var>> res;
 
   std::vector<std::vector<double>> res_d
-      = integrate_ode_rk45(ode, y0, t0, value_of(ts), theta, x, x_int);
+    = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0, t0, value_of(ts), theta, x, x_int);
 
   // here we only test first & last steps, and rely on the
   // fact that results in-between affect the initial
@@ -150,21 +151,21 @@ TEST(StanAgradRevOde_integrate_ode_rk45, time_steps_as_param) {
     EXPECT_NEAR(res_d[99][0], res[99][0].val(), 1e-5);
     EXPECT_NEAR(res_d[99][1], res[99][1].val(), 1e-5);
   };
-  res = integrate_ode_rk45(ode, y0, t0, ts, theta, x, x_int);
+  res = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0, t0, ts, theta, x, x_int);
   test_val();
-  res = integrate_ode_rk45(ode, y0v, t0, ts, theta, x, x_int);
+  res = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0v, t0, ts, theta, x, x_int);
   test_val();
-  res = integrate_ode_rk45(ode, y0, t0, ts, thetav, x, x_int);
+  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(ode, y0, t0, ts, thetav, x, x_int);
   test_val();
-  res = integrate_ode_rk45(ode, y0v, t0, ts, thetav, x, x_int);
+  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(ode, y0v, t0, ts, thetav, x, x_int);
   test_val();
-  res = integrate_ode_rk45(ode, y0, t0v, ts, theta, x, x_int);
+  res = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0, t0v, ts, theta, x, x_int);
   test_val();
-  res = integrate_ode_rk45(ode, y0v, t0v, ts, theta, x, x_int);
+  res = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0v, t0v, ts, theta, x, x_int);
   test_val();
-  res = integrate_ode_rk45(ode, y0, t0v, ts, thetav, x, x_int);
+  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(ode, y0, t0v, ts, thetav, x, x_int);
   test_val();
-  res = integrate_ode_rk45(ode, y0v, t0v, ts, thetav, x, x_int);
+  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(ode, y0v, t0v, ts, thetav, x, x_int);
   test_val();
 }
 
@@ -213,13 +214,13 @@ TEST(StanAgradRevOde_integrate_ode_rk45, time_steps_as_param_AD) {
       }
     }
   };
-  res = integrate_ode_rk45(ode, y0, t0, ts, theta, x, x_int);
+  res = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0, t0, ts, theta, x, x_int);
   test_ad();
-  res = integrate_ode_rk45(ode, y0v, t0, ts, theta, x, x_int);
+  res = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0v, t0, ts, theta, x, x_int);
   test_ad();
-  res = integrate_ode_rk45(ode, y0, t0, ts, thetav, x, x_int);
+  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(ode, y0, t0, ts, thetav, x, x_int);
   test_ad();
-  res = integrate_ode_rk45(ode, y0v, t0, ts, thetav, x, x_int);
+  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(ode, y0v, t0, ts, thetav, x, x_int);
   test_ad();
 }
 
@@ -258,12 +259,12 @@ TEST(StanAgradRevOde_integrate_ode_rk45, t0_as_param_AD) {
       }
     }
   };
-  res = integrate_ode_rk45(ode, y0, t0v, ts, theta, x, x_int);
+  res = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0, t0v, ts, theta, x, x_int);
   test_ad();
-  res = integrate_ode_rk45(ode, y0v, t0v, ts, theta, x, x_int);
+  res = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0v, t0v, ts, theta, x, x_int);
   test_ad();
-  res = integrate_ode_rk45(ode, y0, t0v, ts, thetav, x, x_int);
+  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(ode, y0, t0v, ts, thetav, x, x_int);
   test_ad();
-  res = integrate_ode_rk45(ode, y0v, t0v, ts, thetav, x, x_int);
+  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(ode, y0v, t0v, ts, thetav, x, x_int);
   test_ad();
 }
diff --git a/test/unit/math/rev/functor/util.hpp b/test/unit/math/rev/functor/util.hpp
index b24249de41a..425a4c897f2 100644
--- a/test/unit/math/rev/functor/util.hpp
+++ b/test/unit/math/rev/functor/util.hpp
@@ -29,9 +29,9 @@ std::vector<std::vector<double> > finite_diff_params(
   std::vector<std::vector<double> > ode_res_ub;
   std::vector<std::vector<double> > ode_res_lb;
 
-  ode_res_ub = stan::math::integrate_ode_rk45(f, y_in, t_in, ts, theta_ub, x,
+  ode_res_ub = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(f, y_in, t_in, ts, theta_ub, x,
                                               x_int, &msgs);
-  ode_res_lb = stan::math::integrate_ode_rk45(f, y_in, t_in, ts, theta_lb, x,
+  ode_res_lb = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(f, y_in, t_in, ts, theta_lb, x,
                                               x_int, &msgs);
 
   std::vector<std::vector<double> > results(ts.size());
@@ -65,9 +65,9 @@ std::vector<std::vector<double> > finite_diff_initial_position(
   std::vector<std::vector<double> > ode_res_ub;
   std::vector<std::vector<double> > ode_res_lb;
 
-  ode_res_ub = stan::math::integrate_ode_rk45(f, y_in_ub, t_in, ts, theta, x,
+  ode_res_ub = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(f, y_in_ub, t_in, ts, theta, x,
                                               x_int, &msgs);
-  ode_res_lb = stan::math::integrate_ode_rk45(f, y_in_lb, t_in, ts, theta, x,
+  ode_res_lb = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(f, y_in_lb, t_in, ts, theta, x,
                                               x_int, &msgs);
 
   std::vector<std::vector<double> > results(ts.size());
@@ -103,7 +103,7 @@ void test_ode_finite_diff_dv(const F& f, const double& t_in,
 
   std::vector<std::vector<stan::math::var> > ode_res;
 
-  ode_res = stan::math::integrate_ode_rk45(f, y_in, t_in, ts, theta_v, x, x_int,
+  ode_res = stan::math::integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(f, y_in, t_in, ts, theta_v, x, x_int,
                                            &msgs);
 
   for (size_t i = 0; i < ts.size(); i++) {
@@ -147,7 +147,7 @@ void test_ode_finite_diff_vd(const F& f, const double& t_in,
 
   std::vector<std::vector<stan::math::var> > ode_res;
 
-  ode_res = stan::math::integrate_ode_rk45(f, y_in_v, t_in, ts, theta, x, x_int,
+  ode_res = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(f, y_in_v, t_in, ts, theta, x, x_int,
                                            &msgs);
 
   for (size_t i = 0; i < ts.size(); i++) {
@@ -206,7 +206,7 @@ void test_ode_finite_diff_vv(const F& f, const double& t_in,
 
   std::vector<std::vector<stan::math::var> > ode_res;
 
-  ode_res = stan::math::integrate_ode_rk45(f, y_in_v, t_in, ts, theta_v, x,
+  ode_res = stan::math::integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(f, y_in_v, t_in, ts, theta_v, x,
                                            x_int, &msgs);
 
   for (size_t i = 0; i < ts.size(); i++) {
@@ -242,13 +242,13 @@ void test_ode_error_conditions(F& f, const double& t0,
   using stan::math::integrate_ode_rk45;
   std::stringstream msgs;
 
-  ASSERT_NO_THROW(integrate_ode_rk45(f, y0, t0, ts, theta, x, x_int, 0));
+  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x, x_int, 0)));
   ASSERT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T1> y0_bad;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0_bad, t0, ts, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
       std::invalid_argument, "initial state has size 0");
   EXPECT_EQ("", msgs.str());
 
@@ -258,14 +258,14 @@ void test_ode_error_conditions(F& f, const double& t0,
   expected_msg << "initial time is " << t0_bad << ", but must be less than "
                << ts[0];
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0_bad, ts, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
       std::domain_error, expected_msg.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<double> ts_bad;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
       std::invalid_argument, "times has size 0");
   EXPECT_EQ("", msgs.str());
 
@@ -273,14 +273,14 @@ void test_ode_error_conditions(F& f, const double& t0,
   ts_bad.push_back(3);
   ts_bad.push_back(1);
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
       std::domain_error, "times is not a valid ordered vector");
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T2> theta_bad;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0, ts, theta_bad, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
       std::out_of_range, "vector");
   EXPECT_EQ("", msgs.str());
 
@@ -288,7 +288,7 @@ void test_ode_error_conditions(F& f, const double& t0,
     msgs.clear();
     std::vector<double> x_bad;
     EXPECT_THROW_MSG(
-        integrate_ode_rk45(f, y0, t0, ts, theta, x_bad, x_int, &msgs),
+		     (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
         std::out_of_range, "vector");
     EXPECT_EQ("", msgs.str());
   }
@@ -297,7 +297,7 @@ void test_ode_error_conditions(F& f, const double& t0,
     msgs.clear();
     std::vector<int> x_int_bad;
     EXPECT_THROW_MSG(
-        integrate_ode_rk45(f, y0, t0, ts, theta, x, x_int_bad, &msgs),
+		     (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x, x_int_bad, &msgs)),
         std::out_of_range, "vector");
     EXPECT_EQ("", msgs.str());
   }
@@ -316,27 +316,27 @@ void test_ode_error_conditions_nan(F& f, const double& t0,
   std::stringstream expected_is_nan;
   expected_is_nan << "is " << nan;
 
-  ASSERT_NO_THROW(integrate_ode_rk45(f, y0, t0, ts, theta, x, x_int, 0));
+  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x, x_int, 0)));
   ASSERT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T1> y0_bad = y0;
   y0_bad[0] = nan;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0_bad, t0, ts, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
       std::domain_error, "initial state");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0_bad, t0, ts, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
       std::domain_error, expected_is_nan.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   double t0_bad = nan;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0_bad, ts, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
       std::domain_error, "initial time");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0_bad, ts, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
       std::domain_error, expected_is_nan.str());
   EXPECT_EQ("", msgs.str());
 
@@ -344,10 +344,10 @@ void test_ode_error_conditions_nan(F& f, const double& t0,
   std::vector<double> ts_bad = ts;
   ts_bad[0] = nan;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
       std::domain_error, "times");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
       std::domain_error, expected_is_nan.str());
   EXPECT_EQ("", msgs.str());
 
@@ -355,10 +355,10 @@ void test_ode_error_conditions_nan(F& f, const double& t0,
   std::vector<T2> theta_bad = theta;
   theta_bad[0] = nan;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0, ts, theta_bad, x, x_int, &msgs),
-      std::domain_error, "parameter vector");
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+      std::domain_error, "ode parameters and data");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0, ts, theta_bad, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
       std::domain_error, expected_is_nan.str());
   EXPECT_EQ("", msgs.str());
 
@@ -367,10 +367,10 @@ void test_ode_error_conditions_nan(F& f, const double& t0,
     std::vector<double> x_bad = x;
     x_bad[0] = nan;
     EXPECT_THROW_MSG(
-        integrate_ode_rk45(f, y0, t0, ts, theta, x_bad, x_int, &msgs),
-        std::domain_error, "continuous data");
+		     (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+        std::domain_error, "ode parameters and data");
     EXPECT_THROW_MSG(
-        integrate_ode_rk45(f, y0, t0, ts, theta, x_bad, x_int, &msgs),
+		     (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
         std::domain_error, expected_is_nan.str());
     EXPECT_EQ("", msgs.str());
   }
@@ -391,41 +391,41 @@ void test_ode_error_conditions_inf(F& f, const double& t0,
   std::stringstream expected_is_neg_inf;
   expected_is_neg_inf << "is " << -inf;
 
-  ASSERT_NO_THROW(integrate_ode_rk45(f, y0, t0, ts, theta, x, x_int, 0));
+  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x, x_int, 0)));
   ASSERT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T1> y0_bad = y0;
   y0_bad[0] = inf;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0_bad, t0, ts, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
       std::domain_error, "initial state");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0_bad, t0, ts, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
       std::domain_error, expected_is_inf.str());
   y0_bad[0] = -inf;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0_bad, t0, ts, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
       std::domain_error, "initial state");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0_bad, t0, ts, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
       std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   double t0_bad = inf;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0_bad, ts, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
       std::domain_error, "initial time");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0_bad, ts, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
       std::domain_error, expected_is_inf.str());
   t0_bad = -inf;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0_bad, ts, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
       std::domain_error, "initial time");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0_bad, ts, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
       std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
 
@@ -433,17 +433,17 @@ void test_ode_error_conditions_inf(F& f, const double& t0,
   std::vector<double> ts_bad = ts;
   ts_bad[0] = inf;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
       std::domain_error, "times");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
       std::domain_error, expected_is_inf.str());
   ts_bad[0] = -inf;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
       std::domain_error, "times");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
       std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
 
@@ -451,17 +451,17 @@ void test_ode_error_conditions_inf(F& f, const double& t0,
   std::vector<T2> theta_bad = theta;
   theta_bad[0] = inf;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0, ts, theta_bad, x, x_int, &msgs),
-      std::domain_error, "parameter vector");
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+      std::domain_error, "ode parameters and data");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0, ts, theta_bad, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
       std::domain_error, expected_is_inf.str());
   theta_bad[0] = -inf;
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0, ts, theta_bad, x, x_int, &msgs),
-      std::domain_error, "parameter vector");
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+      std::domain_error, "ode parameters and data");
   EXPECT_THROW_MSG(
-      integrate_ode_rk45(f, y0, t0, ts, theta_bad, x, x_int, &msgs),
+		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
       std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
 
@@ -470,17 +470,17 @@ void test_ode_error_conditions_inf(F& f, const double& t0,
     std::vector<double> x_bad = x;
     x_bad[0] = inf;
     EXPECT_THROW_MSG(
-        integrate_ode_rk45(f, y0, t0, ts, theta, x_bad, x_int, &msgs),
-        std::domain_error, "continuous data");
+		     (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+        std::domain_error, "ode parameters and data");
     EXPECT_THROW_MSG(
-        integrate_ode_rk45(f, y0, t0, ts, theta, x_bad, x_int, &msgs),
+		     (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
         std::domain_error, expected_is_inf.str());
     x_bad[0] = -inf;
     EXPECT_THROW_MSG(
-        integrate_ode_rk45(f, y0, t0, ts, theta, x_bad, x_int, &msgs),
-        std::domain_error, "continuous data");
+		     (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+        std::domain_error, "ode parameters and data");
     EXPECT_THROW_MSG(
-        integrate_ode_rk45(f, y0, t0, ts, theta, x_bad, x_int, &msgs),
+		     (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
         std::domain_error, expected_is_neg_inf.str());
     EXPECT_EQ("", msgs.str());
   }
@@ -543,3 +543,4 @@ void test_ode(const F& f, const double& t_in, const std::vector<double>& ts,
   test_ode_error_conditions_dv(f, t_in, ts, y_in, theta, x, x_int);
   test_ode_error_conditions_vv(f, t_in, ts, y_in, theta, x, x_int);
 }
+
diff --git a/test/unit/math/rev/functor/util_cvodes_bdf.hpp b/test/unit/math/rev/functor/util_cvodes_bdf.hpp
index cc11a004a81..2810e376acc 100644
--- a/test/unit/math/rev/functor/util_cvodes_bdf.hpp
+++ b/test/unit/math/rev/functor/util_cvodes_bdf.hpp
@@ -355,7 +355,7 @@ void test_ode_error_conditions_nan(F& f, const double& t0,
   theta_bad[0] = nan;
   EXPECT_THROW_MSG(integrate_ode_bdf(f, y0, t0, ts, theta_bad, x, x_int, &msgs,
                                      1e-8, 1e-10, 1e6),
-                   std::domain_error, "parameter vector");
+                   std::domain_error, "ode parameters and data");
   EXPECT_THROW_MSG(integrate_ode_bdf(f, y0, t0, ts, theta_bad, x, x_int, &msgs,
                                      1e-8, 1e-10, 1e6),
                    std::domain_error, expected_is_nan.str());
@@ -367,7 +367,7 @@ void test_ode_error_conditions_nan(F& f, const double& t0,
     x_bad[0] = nan;
     EXPECT_THROW_MSG(integrate_ode_bdf(f, y0, t0, ts, theta, x_bad, x_int,
                                        &msgs, 1e-8, 1e-10, 1e6),
-                     std::domain_error, "continuous data");
+                     std::domain_error, "ode parameters and data");
     EXPECT_THROW_MSG(integrate_ode_bdf(f, y0, t0, ts, theta, x_bad, x_int,
                                        &msgs, 1e-8, 1e-10, 1e6),
                      std::domain_error, expected_is_nan.str());
@@ -451,12 +451,12 @@ void test_ode_error_conditions_inf(F& f, const double& t0,
   std::vector<T2> theta_bad = theta;
   theta_bad[0] = inf;
   EXPECT_THROW_MSG(integrate_ode_bdf(f, y0, t0, ts, theta_bad, x, x_int),
-                   std::domain_error, "parameter vector");
+                   std::domain_error, "ode parameters and data");
   EXPECT_THROW_MSG(integrate_ode_bdf(f, y0, t0, ts, theta_bad, x, x_int),
                    std::domain_error, expected_is_inf.str());
   theta_bad[0] = -inf;
   EXPECT_THROW_MSG(integrate_ode_bdf(f, y0, t0, ts, theta_bad, x, x_int),
-                   std::domain_error, "parameter vector");
+                   std::domain_error, "ode parameters and data");
   EXPECT_THROW_MSG(integrate_ode_bdf(f, y0, t0, ts, theta_bad, x, x_int),
                    std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
@@ -466,12 +466,12 @@ void test_ode_error_conditions_inf(F& f, const double& t0,
     std::vector<double> x_bad = x;
     x_bad[0] = inf;
     EXPECT_THROW_MSG(integrate_ode_bdf(f, y0, t0, ts, theta, x_bad, x_int),
-                     std::domain_error, "continuous data");
+                     std::domain_error, "ode parameters and data");
     EXPECT_THROW_MSG(integrate_ode_bdf(f, y0, t0, ts, theta, x_bad, x_int),
                      std::domain_error, expected_is_inf.str());
     x_bad[0] = -inf;
     EXPECT_THROW_MSG(integrate_ode_bdf(f, y0, t0, ts, theta, x_bad, x_int),
-                     std::domain_error, "continuous data");
+                     std::domain_error, "ode parameters and data");
     EXPECT_THROW_MSG(integrate_ode_bdf(f, y0, t0, ts, theta, x_bad, x_int),
                      std::domain_error, expected_is_neg_inf.str());
     EXPECT_EQ("", msgs.str());

From cf48965d278c4e32f7ade5f45fd4d350acdb0ffd Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Sat, 25 Jan 2020 17:44:58 -0500
Subject: [PATCH 076/189] [Jenkins] auto-formatting by clang-format version
 5.0.2-svn328729-1~exp1~20180509124008.99 (branches/release_50)

---
 stan/math/rev/fun/accumulate_adjoints.hpp     |  36 +-
 stan/math/rev/fun/count_vars.hpp              |  30 +-
 stan/math/rev/fun/deep_copy.hpp               |   7 +-
 stan/math/rev/fun/save_varis.hpp              |  21 +-
 .../math/rev/functor/coupled_ode_observer.hpp |  88 +++--
 stan/math/rev/functor/coupled_ode_system.hpp  |  59 +--
 stan/math/rev/functor/cvodes_integrator.hpp   |  18 +-
 stan/math/rev/functor/cvodes_ode_data.hpp     |  32 +-
 stan/math/rev/functor/integrate_ode_bdf.hpp   |   9 +-
 stan/math/rev/functor/integrate_ode_rk45.hpp  |  29 +-
 .../functor/integrate_ode_bdf_prim_test.cpp   |   1 -
 .../functor/integrate_ode_bdf_rev_test.cpp    |   5 +-
 .../functor/integrate_ode_rk45_prim_test.cpp  | 300 ++++++++-------
 .../functor/integrate_ode_rk45_rev_test.cpp   |  69 ++--
 test/unit/math/rev/functor/util.hpp           | 346 ++++++++++--------
 15 files changed, 590 insertions(+), 460 deletions(-)

diff --git a/stan/math/rev/fun/accumulate_adjoints.hpp b/stan/math/rev/fun/accumulate_adjoints.hpp
index 83873984e08..b0c043d1325 100644
--- a/stan/math/rev/fun/accumulate_adjoints.hpp
+++ b/stan/math/rev/fun/accumulate_adjoints.hpp
@@ -13,47 +13,41 @@ namespace internal {
 double* accumulate_adjoints(double* x) { return x; }
 
 template <typename... Pargs>
-double* accumulate_adjoints(double* dest, const var& x,
-			    const Pargs&... args);
+double* accumulate_adjoints(double* dest, const var& x, const Pargs&... args);
 
 template <typename... Pargs>
 double* accumulate_adjoints(double* dest, const std::vector<var>& x,
-			    const Pargs&... args);
+                            const Pargs&... args);
 
-template <typename T, require_t<is_var<scalar_type_t<T>>>...,
-	  typename... Pargs>
+template <typename T, require_t<is_var<scalar_type_t<T>>>..., typename... Pargs>
 double* accumulate_adjoints(double* dest, const std::vector<T>& x,
-			    const Pargs&... args);
+                            const Pargs&... args);
 
 template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
-double* accumulate_adjoints(double* dest, const Mat& x,
-			    const Pargs&... args);
+double* accumulate_adjoints(double* dest, const Mat& x, const Pargs&... args);
 
 template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>...,
-	  typename... Pargs>
-double* accumulate_adjoints(double* dest, Arith&& x,
-			    const Pargs&... args);
+          typename... Pargs>
+double* accumulate_adjoints(double* dest, Arith&& x, const Pargs&... args);
 
 template <typename... Pargs>
-double* accumulate_adjoints(double* dest, const var& x,
-			    const Pargs&... args) {
+double* accumulate_adjoints(double* dest, const var& x, const Pargs&... args) {
   *dest += x.adj();
   return accumulate_adjoints(dest + 1, args...);
 }
 
 template <typename... Pargs>
 double* accumulate_adjoints(double* dest, const std::vector<var>& x,
-			    const Pargs&... args) {
+                            const Pargs&... args) {
   for (size_t i = 0; i < x.size(); ++i) {
     dest[i] += x[i].adj();
   }
   return accumulate_adjoints(dest + x.size(), args...);
 }
 
-template <typename T, require_t<is_var<scalar_type_t<T>>>...,
-	  typename... Pargs>
+template <typename T, require_t<is_var<scalar_type_t<T>>>..., typename... Pargs>
 double* accumulate_adjoints(double* dest, const std::vector<T>& x,
-			    const Pargs&... args) {
+                            const Pargs&... args) {
   for (size_t i = 0; i < x.size(); ++i) {
     dest = accumulate_adjoints(dest, x[i]);
   }
@@ -61,8 +55,7 @@ double* accumulate_adjoints(double* dest, const std::vector<T>& x,
 }
 
 template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
-double* accumulate_adjoints(double* dest, const Mat& x,
-			    const Pargs&... args) {
+double* accumulate_adjoints(double* dest, const Mat& x, const Pargs&... args) {
   for (size_t i = 0; i < x.size(); ++i) {
     dest[i] += x(i).adj();
   }
@@ -70,9 +63,8 @@ double* accumulate_adjoints(double* dest, const Mat& x,
 }
 
 template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>...,
-	  typename... Pargs>
-double* accumulate_adjoints(double* dest, Arith&& x,
-			    const Pargs&... args) {
+          typename... Pargs>
+double* accumulate_adjoints(double* dest, Arith&& x, const Pargs&... args) {
   return accumulate_adjoints(dest, args...);
 }
 
diff --git a/stan/math/rev/fun/count_vars.hpp b/stan/math/rev/fun/count_vars.hpp
index 84c834863ed..5ec641bfe8f 100644
--- a/stan/math/rev/fun/count_vars.hpp
+++ b/stan/math/rev/fun/count_vars.hpp
@@ -14,35 +14,31 @@ size_t count_vars_impl(size_t count) { return count; }
 
 template <typename... Pargs>
 size_t count_vars_impl(size_t count, const std::vector<var>& x,
-		      const Pargs&... args);
+                       const Pargs&... args);
 
-template <typename T, require_t<is_var<scalar_type_t<T>>>...,
-	  typename... Pargs>
+template <typename T, require_t<is_var<scalar_type_t<T>>>..., typename... Pargs>
 size_t count_vars_impl(size_t count, const std::vector<T>& x,
-		      const Pargs&... args);
+                       const Pargs&... args);
 
 template <typename Mat, require_eigen_vt<is_var, Mat>..., typename... Pargs>
-size_t count_vars_impl(size_t count, const Mat& x,
-		      const Pargs&... args);
+size_t count_vars_impl(size_t count, const Mat& x, const Pargs&... args);
 
 template <typename... Pargs>
-size_t count_vars_impl(size_t count, const var& x,
-		      const Pargs&... args);
+size_t count_vars_impl(size_t count, const var& x, const Pargs&... args);
 
 template <typename... Pargs, typename Arith,
-	  require_arithmetic_t<scalar_type_t<Arith>>...>
+          require_arithmetic_t<scalar_type_t<Arith>>...>
 size_t count_vars_impl(size_t count, Arith& x, const Pargs&... args);
 
 template <typename... Pargs>
 size_t count_vars_impl(size_t count, const std::vector<var>& x,
-		      const Pargs&... args) {
+                       const Pargs&... args) {
   return count_vars_impl(count + x.size(), args...);
 }
 
-template <typename T, require_t<is_var<scalar_type_t<T>>>...,
-	  typename... Pargs>
+template <typename T, require_t<is_var<scalar_type_t<T>>>..., typename... Pargs>
 size_t count_vars_impl(size_t count, const std::vector<T>& x,
-		      const Pargs&... args) {
+                       const Pargs&... args) {
   for (size_t i = 0; i < x.size(); i++) {
     count = count_vars_impl(count, x[i]);
   }
@@ -50,19 +46,17 @@ size_t count_vars_impl(size_t count, const std::vector<T>& x,
 }
 
 template <typename Mat, require_eigen_vt<is_var, Mat>..., typename... Pargs>
-size_t count_vars_impl(size_t count, const Mat& x,
-		      const Pargs&... args) {
+size_t count_vars_impl(size_t count, const Mat& x, const Pargs&... args) {
   return count_vars_impl(count + x.size(), args...);
 }
 
 template <typename... Pargs>
-size_t count_vars_impl(size_t count, const var& x,
-		      const Pargs&... args) {
+size_t count_vars_impl(size_t count, const var& x, const Pargs&... args) {
   return count_vars_impl(count + 1, args...);
 }
 
 template <typename... Pargs, typename Arith,
-	  require_arithmetic_t<scalar_type_t<Arith>>...>
+          require_arithmetic_t<scalar_type_t<Arith>>...>
 size_t count_vars_impl(size_t count, Arith& x, const Pargs&... args) {
   return count_vars_impl(count, args...);
 }
diff --git a/stan/math/rev/fun/deep_copy.hpp b/stan/math/rev/fun/deep_copy.hpp
index a287ae38b26..5f783a05ec2 100644
--- a/stan/math/rev/fun/deep_copy.hpp
+++ b/stan/math/rev/fun/deep_copy.hpp
@@ -15,9 +15,7 @@ const T& deep_copy(const T& arg) {
   return arg;
 }
 
-var deep_copy(const var& arg) {
-  return var(new vari(arg.val(), false));
-}
+var deep_copy(const var& arg) { return var(new vari(arg.val(), false)); }
 
 std::vector<var> deep_copy(const std::vector<var>& arg) {
   std::vector<var> copy(arg.size());
@@ -37,7 +35,8 @@ std::vector<T> deep_copy(const std::vector<T>& arg) {
 }
 
 template <int RowType, int ColType>
-Eigen::Matrix<var, RowType, ColType> deep_copy(const Eigen::Matrix<var, RowType, ColType>& arg) {
+Eigen::Matrix<var, RowType, ColType> deep_copy(
+    const Eigen::Matrix<var, RowType, ColType>& arg) {
   Eigen::Matrix<var, RowType, ColType> copy(arg.rows(), arg.cols());
   for (size_t i = 0; i < arg.size(); ++i) {
     copy(i) = new vari(arg(i).val(), false);
diff --git a/stan/math/rev/fun/save_varis.hpp b/stan/math/rev/fun/save_varis.hpp
index bfda34d23c2..df3044b401a 100644
--- a/stan/math/rev/fun/save_varis.hpp
+++ b/stan/math/rev/fun/save_varis.hpp
@@ -16,19 +16,16 @@ template <typename... Pargs>
 vari** save_varis(vari** dest, const var& x, const Pargs&... args);
 
 template <typename... Pargs>
-vari** save_varis(vari** dest, const std::vector<var>& x,
-		  const Pargs&... args);
+vari** save_varis(vari** dest, const std::vector<var>& x, const Pargs&... args);
 
-template <typename T, require_t<is_var<scalar_type_t<T>>>...,
-	  typename... Pargs>
-vari** save_varis(vari** dest, const std::vector<T>& x,
-		  const Pargs&... args);
+template <typename T, require_t<is_var<scalar_type_t<T>>>..., typename... Pargs>
+vari** save_varis(vari** dest, const std::vector<T>& x, const Pargs&... args);
 
 template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
 vari** save_varis(vari** dest, const Mat& x, const Pargs&... args);
 
 template <typename R, require_arithmetic_t<scalar_type_t<R>>...,
-	  typename... Pargs>
+          typename... Pargs>
 vari** save_varis(vari** dest, const R& x, const Pargs&... args);
 
 template <typename... Pargs>
@@ -39,17 +36,15 @@ vari** save_varis(vari** dest, const var& x, const Pargs&... args) {
 
 template <typename... Pargs>
 vari** save_varis(vari** dest, const std::vector<var>& x,
-		  const Pargs&... args) {
+                  const Pargs&... args) {
   for (size_t i = 0; i < x.size(); ++i) {
     dest[i] = x[i].vi_;
   }
   return save_varis(dest + x.size(), args...);
 }
 
-template <typename T, require_t<is_var<scalar_type_t<T>>>...,
-	  typename... Pargs>
-vari** save_varis(vari** dest, const std::vector<T>& x,
-		  const Pargs&... args) {
+template <typename T, require_t<is_var<scalar_type_t<T>>>..., typename... Pargs>
+vari** save_varis(vari** dest, const std::vector<T>& x, const Pargs&... args) {
   for (size_t i = 0; i < x.size(); ++i) {
     dest = save_varis(dest, x[i]);
   }
@@ -65,7 +60,7 @@ vari** save_varis(vari** dest, const Mat& x, const Pargs&... args) {
 }
 
 template <typename R, require_arithmetic_t<scalar_type_t<R>>...,
-	  typename... Pargs>
+          typename... Pargs>
 vari** save_varis(vari** dest, const R& x, const Pargs&... args) {
   return save_varis(dest, args...);
 }
diff --git a/stan/math/rev/functor/coupled_ode_observer.hpp b/stan/math/rev/functor/coupled_ode_observer.hpp
index 263de2b9649..b0a4008722d 100644
--- a/stan/math/rev/functor/coupled_ode_observer.hpp
+++ b/stan/math/rev/functor/coupled_ode_observer.hpp
@@ -26,10 +26,11 @@ namespace math {
  * used in stan-math.
  *
  */
-template <typename T1, typename T_t0, typename T_ts, typename F, typename... Args>
+template <typename T1, typename T_t0, typename T_ts, typename F,
+          typename... Args>
 struct coupled_ode_observer {
   using ReturnType = return_type_t<T1, T_t0, T_ts, Args...>;
-  
+
   const F& f_;
   const std::vector<T1>& y0_;
   const T_t0& t0_;
@@ -60,12 +61,9 @@ struct coupled_ode_observer {
    * @param[out] msgs the print stream for warning messages.
    * @param[out] y reference to a vector of vector of the final return
    */
-  coupled_ode_observer(const F& f,
-		       const std::vector<T1>& y0,
-		       const T_t0& t0,
-                       const std::vector<T_ts>& ts,
-		       const Args&... args,
-		       std::ostream* msgs,
+  coupled_ode_observer(const F& f, const std::vector<T1>& y0, const T_t0& t0,
+                       const std::vector<T_ts>& ts, const Args&... args,
+                       std::ostream* msgs,
                        std::vector<std::vector<ReturnType>>& y)
       : f_(f),
         y0_(y0),
@@ -73,7 +71,7 @@ struct coupled_ode_observer {
         ts_(ts),
         msgs_(msgs),
         y_(y),
-	args_tuple_(args...),
+        args_tuple_(args...),
         N_(y0.size()),
         next_ts_index_(0) {}
 
@@ -90,12 +88,12 @@ struct coupled_ode_observer {
    * @param t time of solution. The time must correspond to the
    * element ts[next_ts_index_]
    */
-  template<bool return_type_is_var = is_var<ReturnType>::value>
-  std::enable_if_t<return_type_is_var>
-  operator()(const std::vector<double>& coupled_state, double t) {
+  template <bool return_type_is_var = is_var<ReturnType>::value>
+  std::enable_if_t<return_type_is_var> operator()(
+      const std::vector<double>& coupled_state, double t) {
     check_less("coupled_ode_observer", "time-state number", next_ts_index_,
                ts_.size());
-    
+
     std::vector<ReturnType> yt;
     yt.reserve(N_);
 
@@ -103,22 +101,31 @@ struct coupled_ode_observer {
     if (stan::is_var<T_ts>::value) {
       std::vector<double> y_dbl(coupled_state.begin(),
                                 coupled_state.begin() + N_);
-      dy_dt = apply([&](const Args&... args) {
-	  return f_(value_of(ts_[next_ts_index_]), y_dbl, value_of(args)..., msgs_);
-	}, args_tuple_);
-      check_size_match("coupled_ode_observer", "dy_dt", dy_dt.size(), "states", N_);
+      dy_dt = apply(
+          [&](const Args&... args) {
+            return f_(value_of(ts_[next_ts_index_]), y_dbl, value_of(args)...,
+                      msgs_);
+          },
+          args_tuple_);
+      check_size_match("coupled_ode_observer", "dy_dt", dy_dt.size(), "states",
+                       N_);
     }
 
     const size_t y0_vars = internal::count_vars(y0_);
-    const size_t args_vars = apply([&](const Args&... args) { return internal::count_vars(args...); }, args_tuple_);
+    const size_t args_vars = apply(
+        [&](const Args&... args) { return internal::count_vars(args...); },
+        args_tuple_);
     // When true this is 1 and not ts_.size() because there's
     //   only one time point involved with this output
     const size_t time_vars = (stan::is_var<T_ts>::value) ? 1 : 0;
     const size_t total_vars = y0_vars + args_vars + time_vars;
-    
+
     for (size_t j = 0; j < N_; j++) {
-      vari** varis = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
-      double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(total_vars);
+      vari** varis
+          = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
+      double* partials
+          = ChainableStack::instance_->memalloc_.alloc_array<double>(
+              total_vars);
 
       vari** varis_ptr = varis;
       double* partials_ptr = partials;
@@ -128,38 +135,41 @@ struct coupled_ode_observer {
       // iterate over parameters for each equation
       varis_ptr = internal::save_varis(varis_ptr, y0_);
       for (std::size_t k = 0; k < y0_vars; k++) {
-	//*varis_ptr = y0[k].vi_;
-	*partials_ptr = coupled_state[N_ + y0_vars * k + j];
-	partials_ptr++;
+        //*varis_ptr = y0[k].vi_;
+        *partials_ptr = coupled_state[N_ + y0_vars * k + j];
+        partials_ptr++;
       }
 
-      varis_ptr = apply([&varis_ptr](const Args&... args) {
-	  return internal::save_varis(varis_ptr, args...);
-	}, args_tuple_);
+      varis_ptr = apply(
+          [&varis_ptr](const Args&... args) {
+            return internal::save_varis(varis_ptr, args...);
+          },
+          args_tuple_);
       for (std::size_t k = 0; k < args_vars; k++) {
-	// dy[j]_dtheta[k]
-	// theta[k].vi_
-	*partials_ptr = coupled_state[N_ + N_ * y0_vars + N_ * k + j];
-	partials_ptr++;
+        // dy[j]_dtheta[k]
+        // theta[k].vi_
+        *partials_ptr = coupled_state[N_ + N_ * y0_vars + N_ * k + j];
+        partials_ptr++;
       }
 
       if (time_vars > 0) {
-	varis_ptr = internal::save_varis(varis_ptr, ts_[next_ts_index_]);
-	*partials_ptr = dy_dt[j];
-	partials_ptr++;
-	// dy[j]_dcurrent_t
+        varis_ptr = internal::save_varis(varis_ptr, ts_[next_ts_index_]);
+        *partials_ptr = dy_dt[j];
+        partials_ptr++;
+        // dy[j]_dcurrent_t
       }
 
-      yt.emplace_back(new precomputed_gradients_vari(coupled_state[j], total_vars, varis, partials));
+      yt.emplace_back(new precomputed_gradients_vari(
+          coupled_state[j], total_vars, varis, partials));
     }
 
     y_.emplace_back(yt);
     next_ts_index_++;
   }
 
-  template<bool return_type_is_var = is_var<ReturnType>::value>
-  std::enable_if_t<not return_type_is_var>
-  operator()(const std::vector<double>& coupled_state, double t) {
+  template <bool return_type_is_var = is_var<ReturnType>::value>
+  std::enable_if_t<not return_type_is_var> operator()(
+      const std::vector<double>& coupled_state, double t) {
     y_.emplace_back(coupled_state);
   }
 };
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index a5761b5b973..d6365f48b4a 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -85,16 +85,15 @@ struct coupled_ode_system {
    * @param[in] x_int integer data
    * @param[in, out] msgs stream for messages
    */
-  coupled_ode_system(const F& f, const std::vector<T1>& y0,
-                     const Args&... args, std::ostream* msgs)
+  coupled_ode_system(const F& f, const std::vector<T1>& y0, const Args&... args,
+                     std::ostream* msgs)
       : f_(f),
         y0_(y0),
-	args_tuple_(args...),
-	y0_vars_(internal::count_vars(y0_)),
-	args_vars_(internal::count_vars(args...)),
+        args_tuple_(args...),
+        y0_vars_(internal::count_vars(y0_)),
+        args_vars_(internal::count_vars(args...)),
         N_(y0.size()),
-        msgs_(msgs) {
-  }
+        msgs_(msgs) {}
 
   /**
    * Calculates the derivative of the coupled ode system with respect
@@ -110,23 +109,26 @@ struct coupled_ode_system {
    * @throw exception if the base ode function does not return the
    *    expected number of derivatives, N.
    */
-  template<bool return_type_is_var = is_var<ReturnType>::value>
-  std::enable_if_t<return_type_is_var>
-  operator()(const std::vector<double>& z, std::vector<double>& dz_dt,
-                  double t) const {
+  template <bool return_type_is_var = is_var<ReturnType>::value>
+  std::enable_if_t<return_type_is_var> operator()(const std::vector<double>& z,
+                                                  std::vector<double>& dz_dt,
+                                                  double t) const {
     using std::vector;
 
     try {
       start_nested();
 
       const vector<var> y_vars(z.begin(), z.begin() + N_);
-      auto local_args_tuple = apply([&](const Args&... args) {
-	  return std::tuple<decltype(internal::deep_copy(args))...>(internal::deep_copy(args)...);
-	}, args_tuple_);
+      auto local_args_tuple = apply(
+          [&](const Args&... args) {
+            return std::tuple<decltype(internal::deep_copy(args))...>(
+                internal::deep_copy(args)...);
+          },
+          args_tuple_);
 
-      vector<var> dy_dt_vars = apply([&](const Args&... args) {
-	  return f_(t, y_vars, args..., msgs_);
-	}, local_args_tuple);
+      vector<var> dy_dt_vars = apply(
+          [&](const Args&... args) { return f_(t, y_vars, args..., msgs_); },
+          local_args_tuple);
 
       check_size_match("coupled_ode_system", "dz_dt", dy_dt_vars.size(),
                        "states", N_);
@@ -148,10 +150,12 @@ struct coupled_ode_system {
           dz_dt[N_ + N_ * j + i] = temp_deriv;
         }
 
-	Eigen::VectorXd args_adjoints = Eigen::VectorXd::Zero(args_vars_);
-	apply([&](const Args&... args) {
-	    internal::accumulate_adjoints(args_adjoints.data(), args...);
-	  }, local_args_tuple);
+        Eigen::VectorXd args_adjoints = Eigen::VectorXd::Zero(args_vars_);
+        apply(
+            [&](const Args&... args) {
+              internal::accumulate_adjoints(args_adjoints.data(), args...);
+            },
+            local_args_tuple);
         for (size_t j = 0; j < args_vars_; j++) {
           double temp_deriv = args_adjoints(j);
           for (size_t k = 0; k < N_; k++) {
@@ -170,13 +174,12 @@ struct coupled_ode_system {
     recover_memory_nested();
   }
 
-  template<bool return_type_is_var = is_var<ReturnType>::value>
-  std::enable_if_t<not return_type_is_var>
-  operator()(const std::vector<double>& y, std::vector<double>& dy_dt,
-                  double t) const {
-    dy_dt = apply([&](const Args&... args) {
-	return f_(t, y, args..., msgs_);
-      }, args_tuple_);
+  template <bool return_type_is_var = is_var<ReturnType>::value>
+  std::enable_if_t<not return_type_is_var> operator()(
+      const std::vector<double>& y, std::vector<double>& dy_dt,
+      double t) const {
+    dy_dt = apply([&](const Args&... args) { return f_(t, y, args..., msgs_); },
+                  args_tuple_);
 
     check_size_match("coupled_ode_system", "y", y.size(), "dy_dt",
                      dy_dt.size());
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 736a018e947..935573e442d 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -68,10 +68,10 @@ class cvodes_integrator {
    * @return a vector of states, each state being a vector of the
    * same size as the state variable, corresponding to a time in ts.
    */
-  template <typename... Args, typename F, typename T_initial,
-	    typename T_t0, typename T_ts>
+  template <typename... Args, typename F, typename T_initial, typename T_t0,
+            typename T_ts>
   std::vector<std::vector<
-		typename stan::return_type<T_initial, T_t0, T_ts, Args...>::type>>
+      typename stan::return_type<T_initial, T_t0, T_ts, Args...>::type>>
   integrate(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
             const std::vector<T_ts>& ts, const Args&... args,
             std::ostream* msgs, double relative_tolerance,
@@ -88,8 +88,10 @@ class cvodes_integrator {
     check_finite(fun, "initial time", t0_dbl);
     check_finite(fun, "times", ts_dbl);
 
-    // Code from: https://stackoverflow.com/a/17340003 . Should probably do something better
-    std::vector<int> unused_temp{ 0, (check_finite(fun, "ode parameters and data", args), 0)... };
+    // Code from: https://stackoverflow.com/a/17340003 . Should probably do
+    // something better
+    std::vector<int> unused_temp{
+        0, (check_finite(fun, "ode parameters and data", args), 0)...};
 
     check_nonzero_size(fun, "times", ts);
     check_nonzero_size(fun, "initial state", y0);
@@ -108,7 +110,6 @@ class cvodes_integrator {
                        "", ", must be greater than 0");
     }
 
-
     const size_t y0_vars = internal::count_vars(y0);
     const size_t args_vars = internal::count_vars(args...);
     const size_t S = y0_vars + args_vars;
@@ -124,9 +125,10 @@ class cvodes_integrator {
     const size_t coupled_size = cvodes_data.coupled_ode_.size();
 
     using return_t = return_type_t<T_initial, T_t0, T_ts, Args...>;
-    
+
     std::vector<std::vector<return_t>> y;
-    coupled_ode_observer<T_initial, T_t0, T_ts, F, Args...> observer(f, y0, t0, ts, args..., msgs, y);
+    coupled_ode_observer<T_initial, T_t0, T_ts, F, Args...> observer(
+        f, y0, t0, ts, args..., msgs, y);
 
     try {
       check_flag_sundials(CVodeInit(cvodes_mem, &ode_data::cv_rhs, t0_dbl,
diff --git a/stan/math/rev/functor/cvodes_ode_data.hpp b/stan/math/rev/functor/cvodes_ode_data.hpp
index aa7d823315c..f7d62224b43 100644
--- a/stan/math/rev/functor/cvodes_ode_data.hpp
+++ b/stan/math/rev/functor/cvodes_ode_data.hpp
@@ -33,6 +33,7 @@ class cvodes_ode_data {
   const size_t S_;
 
   using ode_data = cvodes_ode_data<F, T_initial, Args...>;
+
  public:
   const coupled_ode_system<T_initial, F, Args...> coupled_ode_;
   std::vector<double> coupled_state_;
@@ -63,18 +64,16 @@ class cvodes_ode_data {
    * @param[in] x_int integer data vector for the ODE.
    * @param[in] msgs stream to which messages are printed.
    */
-  cvodes_ode_data(const F& f,
-		  const std::vector<T_initial>& y0,
-		  const Args&... args,
-                  std::ostream* msgs)
+  cvodes_ode_data(const F& f, const std::vector<T_initial>& y0,
+                  const Args&... args, std::ostream* msgs)
       : f_(f),
         y0_(y0),
-	args_tuple_(args...),
+        args_tuple_(args...),
         N_(y0.size()),
         msgs_(msgs),
-	y0_vars_(internal::count_vars(y0_)),
-	args_vars_(internal::count_vars(args...)),
-	S_(y0_vars_ + args_vars_),
+        y0_vars_(internal::count_vars(y0_)),
+        args_vars_(internal::count_vars(args...)),
+        S_(y0_vars_ + args_vars_),
         coupled_ode_(f, y0, args..., msgs),
         coupled_state_(coupled_ode_.initial_state()),
         nv_state_(N_VMake_Serial(N_, &coupled_state_[0])),
@@ -140,9 +139,11 @@ class cvodes_ode_data {
    */
   inline void rhs(double t, const double y[], double dy_dt[]) const {
     const std::vector<double> y_vec(y, y + N_);
-    std::vector<double> dy_dt_vec = apply([&](const Args&... args) {
-	return f_(t, y_vec, value_of(args)..., msgs_);
-      }, args_tuple_);
+    std::vector<double> dy_dt_vec = apply(
+        [&](const Args&... args) {
+          return f_(t, y_vec, value_of(args)..., msgs_);
+        },
+        args_tuple_);
     check_size_match("cvodes_ode_data", "dz_dt", dy_dt_vec.size(), "states",
                      N_);
     std::move(dy_dt_vec.begin(), dy_dt_vec.end(), dy_dt);
@@ -158,9 +159,12 @@ class cvodes_ode_data {
   inline int jacobian_states(double t, const double y[], SUNMatrix J) const {
     start_nested();
     const std::vector<var> y_vec_var(y, y + N_);
-    auto ode_jacobian = apply([&](const Args&... args) {
-	return coupled_ode_system<var, F, decltype(value_of(args))...>(f_, y_vec_var, value_of(args)..., msgs_);
-      }, args_tuple_);
+    auto ode_jacobian = apply(
+        [&](const Args&... args) {
+          return coupled_ode_system<var, F, decltype(value_of(args))...>(
+              f_, y_vec_var, value_of(args)..., msgs_);
+        },
+        args_tuple_);
     std::vector<double>&& jacobian_y = std::vector<double>(ode_jacobian.size());
     ode_jacobian(ode_jacobian.initial_state(), jacobian_y, t);
     std::move(jacobian_y.begin() + N_, jacobian_y.end(), SM_DATA_D(J));
diff --git a/stan/math/rev/functor/integrate_ode_bdf.hpp b/stan/math/rev/functor/integrate_ode_bdf.hpp
index f6052fbc6a0..5a73359490f 100644
--- a/stan/math/rev/functor/integrate_ode_bdf.hpp
+++ b/stan/math/rev/functor/integrate_ode_bdf.hpp
@@ -22,11 +22,10 @@ integrate_ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
                   double absolute_tolerance = 1e-10,
                   long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
   stan::math::cvodes_integrator<CV_BDF> integrator;
-  return integrator.integrate<std::vector<T_param>,
-			      std::vector<double>,
-			      std::vector<int>>(f, y0, t0, ts, theta, x, x_int, msgs,
-                              relative_tolerance, absolute_tolerance,
-                              max_num_steps);
+  return integrator
+      .integrate<std::vector<T_param>, std::vector<double>, std::vector<int>>(
+          f, y0, t0, ts, theta, x, x_int, msgs, relative_tolerance,
+          absolute_tolerance, max_num_steps);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/integrate_ode_rk45.hpp b/stan/math/rev/functor/integrate_ode_rk45.hpp
index aac4e36693e..418e1936663 100644
--- a/stan/math/rev/functor/integrate_ode_rk45.hpp
+++ b/stan/math/rev/functor/integrate_ode_rk45.hpp
@@ -68,20 +68,19 @@ namespace math {
  * same size as the state variable, corresponding to a time in ts.
  */
 
-template <typename ...Args, typename F, typename T1, typename T_t0, typename T_ts>
-std::vector<std::vector<return_type_t<T1, T_t0, T_ts, Args...>>> integrate_ode_rk45(
-    const F& f, const std::vector<T1>& y0, const T_t0& t0,
-    const std::vector<T_ts>& ts,
-    const Args&... args,
-    std::ostream* msgs = nullptr,
-    double relative_tolerance = 1e-6,
-    double absolute_tolerance = 1e-6,
-    int max_num_steps = 1e6) {
+template <typename... Args, typename F, typename T1, typename T_t0,
+          typename T_ts>
+std::vector<std::vector<return_type_t<T1, T_t0, T_ts, Args...>>>
+integrate_ode_rk45(const F& f, const std::vector<T1>& y0, const T_t0& t0,
+                   const std::vector<T_ts>& ts, const Args&... args,
+                   std::ostream* msgs = nullptr,
+                   double relative_tolerance = 1e-6,
+                   double absolute_tolerance = 1e-6, int max_num_steps = 1e6) {
   using boost::numeric::odeint::integrate_times;
   using boost::numeric::odeint::make_dense_output;
   using boost::numeric::odeint::max_step_checker;
   using boost::numeric::odeint::runge_kutta_dopri5;
-  
+
   const double t0_dbl = value_of(t0);
   const std::vector<double> ts_dbl = value_of(ts);
 
@@ -89,8 +88,11 @@ std::vector<std::vector<return_type_t<T1, T_t0, T_ts, Args...>>> integrate_ode_r
   check_finite("integrate_ode_rk45", "initial time", t0_dbl);
   check_finite("integrate_ode_rk45", "times", ts_dbl);
 
-  // Code from: https://stackoverflow.com/a/17340003 . Should probably do something better
-  std::vector<int> unused_temp{ 0, (check_finite("integrate_ode_rk45", "ode parameters and data", args), 0)... };
+  // Code from: https://stackoverflow.com/a/17340003 . Should probably do
+  // something better
+  std::vector<int> unused_temp{
+      0, (check_finite("integrate_ode_rk45", "ode parameters and data", args),
+          0)...};
 
   check_nonzero_size("integrate_ode_rk45", "initial state", y0);
   check_nonzero_size("integrate_ode_rk45", "times", ts_dbl);
@@ -120,7 +122,8 @@ std::vector<std::vector<return_type_t<T1, T_t0, T_ts, Args...>>> integrate_ode_r
   std::copy(ts_dbl.begin(), ts_dbl.end(), ts_vec.begin() + 1);
 
   std::vector<std::vector<return_t>> y;
-  coupled_ode_observer<T1, T_t0, T_ts, F, Args...> observer(f, y0, t0, ts, args..., msgs, y);
+  coupled_ode_observer<T1, T_t0, T_ts, F, Args...> observer(f, y0, t0, ts,
+                                                            args..., msgs, y);
   bool observer_initial_recorded = false;
 
   // avoid recording of the initial state which is included by the
diff --git a/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp
index 137827effbf..3027856ee1f 100644
--- a/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp
@@ -361,4 +361,3 @@ TEST(StanMathOde_integrate_ode_bdf, error_conditions_bad_ode) {
                                      1e-8, 1e-10, 1e6),
                    std::invalid_argument, error_msg);
 }
-
diff --git a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
index 42065d3eeb1..987f49a61ee 100644
--- a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
@@ -53,7 +53,7 @@ void sho_finite_diff_test(double t0) {
   sho_value_test<harm_osc_ode_fun, var, double>(harm_osc, y0, t0, ts, theta, x,
                                                 x_int);
   sho_value_test<harm_osc_ode_fun, var, var>(harm_osc, y0, t0, ts, theta, x,
-                                            x_int);
+                                             x_int);
 }
 
 void sho_data_finite_diff_test(double t0) {
@@ -134,7 +134,7 @@ TEST(StanAgradRevOde_integrate_ode_bdf, harmonic_oscillator_error) {
   sho_error_test<double, var>(harm_osc, y0, t0, ts, theta, x, x_int, error_msg);
   sho_error_test<var, double>(harm_osc, y0, t0, ts, theta, x, x_int, error_msg);
   sho_error_test<var, var>(harm_osc, y0, t0, ts, theta, x, x_int, error_msg);
-  }
+}
 
 TEST(StanAgradRevOde_integrate_ode_bdf, lorenz_finite_diff) {
   lorenz_ode_fun lorenz;
@@ -304,4 +304,3 @@ TEST(StanAgradRevOde_integrate_ode_bdf, t0_as_param_AD) {
   res = integrate_ode_bdf(ode, y0v, t0v, ts, thetav, x, x_int);
   test_ad();
 }
-
diff --git a/test/unit/math/rev/functor/integrate_ode_rk45_prim_test.cpp b/test/unit/math/rev/functor/integrate_ode_rk45_prim_test.cpp
index a72d02a356a..f1d219eab4e 100644
--- a/test/unit/math/rev/functor/integrate_ode_rk45_prim_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_rk45_prim_test.cpp
@@ -14,14 +14,16 @@ std::ostream* msgs = nullptr;
 template <typename F, typename... Args>
 void sho_death_test(F harm_osc, std::vector<double>& y0, double t0,
                     std::vector<double>& ts, Args&... args) {
-  EXPECT_DEATH(stan::math::integrate_ode_rk45<Args...>(harm_osc, y0, t0, ts, args...), "");
+  EXPECT_DEATH(
+      stan::math::integrate_ode_rk45<Args...>(harm_osc, y0, t0, ts, args...),
+      "");
 }
 
 template <typename F, typename... Args>
 void sho_value_test(F harm_osc, std::vector<double>& y0, double t0,
                     std::vector<double>& ts, Args&... args) {
-  std::vector<std::vector<double> > ode_res_vd
-    = stan::math::integrate_ode_rk45<Args...>(harm_osc, y0, t0, ts, args...);
+  std::vector<std::vector<double>> ode_res_vd
+      = stan::math::integrate_ode_rk45<Args...>(harm_osc, y0, t0, ts, args...);
   EXPECT_NEAR(0.995029, ode_res_vd[0][0], 1e-5);
   EXPECT_NEAR(-0.0990884, ode_res_vd[0][1], 1e-5);
 
@@ -99,55 +101,69 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions) {
   std::vector<double> x(3, 1);
   std::vector<int> x_int(2, 0);
 
-  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x, x_int)));
+  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                      std::vector<int>>(harm_osc, y0, t0, ts,
+                                                        theta, x, x_int)));
 
   std::vector<double> y0_bad;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
-      std::invalid_argument, "initial state has size 0");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0_bad, t0,
+                                                         ts, theta, x, x_int)),
+                   std::invalid_argument, "initial state has size 0");
 
   double t0_bad = 2.0;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
-      std::domain_error, "initial time is 2, but must be less than 0.1");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0, t0_bad,
+                                                         ts, theta, x, x_int)),
+                   std::domain_error,
+                   "initial time is 2, but must be less than 0.1");
 
   std::vector<double> ts_bad;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-      std::invalid_argument, "times has size 0");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(
+                       harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+                   std::invalid_argument, "times has size 0");
 
   ts_bad.push_back(3);
   ts_bad.push_back(1);
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-      std::domain_error, "times is not a valid ordered vector");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(
+                       harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+                   std::domain_error, "times is not a valid ordered vector");
 
   std::vector<double> theta_bad;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
-      std::out_of_range, "vector");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0, t0, ts,
+                                                         theta_bad, x, x_int)),
+                   std::out_of_range, "vector");
 
   std::vector<double> x_bad;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
-      std::out_of_range, "vector");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0, t0, ts,
+                                                         theta, x_bad, x_int)),
+                   std::out_of_range, "vector");
 
   std::vector<int> x_int_bad;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x, x_int_bad)),
-      std::out_of_range, "vector");
-
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x, x_int, 0,
-												   -1, 1e-6, 10)),
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0, t0, ts,
+                                                         theta, x, x_int_bad)),
+                   std::out_of_range, "vector");
+
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(
+                       harm_osc, y0, t0, ts, theta, x, x_int, 0, -1, 1e-6, 10)),
                    std::invalid_argument, "relative_tolerance");
 
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x, x_int, 0,
-												   1e-6, -1, 10)),
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(
+                       harm_osc, y0, t0, ts, theta, x, x_int, 0, 1e-6, -1, 10)),
                    std::invalid_argument, "absolute_tolerance");
 
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x, x_int, 0,
-												  1e-6, 1e-6, -1)),
-                   std::invalid_argument, "max_num_steps");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                          std::vector<int>>(harm_osc, y0, t0, ts, theta, x,
+                                            x_int, 0, 1e-6, 1e-6, -1)),
+      std::invalid_argument, "max_num_steps");
 }
 
 TEST(StanMathOde_integrate_ode_rk45, error_conditions_nan) {
@@ -170,7 +186,9 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions_nan) {
   std::vector<double> x(3, 1);
   std::vector<int> x_int(2, 0);
 
-  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x, x_int)));
+  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                      std::vector<int>>(harm_osc, y0, t0, ts,
+                                                        theta, x, x_int)));
 
   double nan = std::numeric_limits<double>::quiet_NaN();
   std::stringstream expected_is_nan;
@@ -178,48 +196,58 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions_nan) {
 
   std::vector<double> y0_bad = y0;
   y0_bad[0] = nan;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
-      std::domain_error, "initial state");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
-      std::domain_error, expected_is_nan.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0_bad, t0,
+                                                         ts, theta, x, x_int)),
+                   std::domain_error, "initial state");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0_bad, t0,
+                                                         ts, theta, x, x_int)),
+                   std::domain_error, expected_is_nan.str());
 
   double t0_bad = nan;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
-      std::domain_error, "initial time");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
-      std::domain_error, expected_is_nan.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0, t0_bad,
+                                                         ts, theta, x, x_int)),
+                   std::domain_error, "initial time");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0, t0_bad,
+                                                         ts, theta, x, x_int)),
+                   std::domain_error, expected_is_nan.str());
 
   std::vector<double> ts_bad = ts;
   ts_bad[0] = nan;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-      std::domain_error, "times");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-      std::domain_error, expected_is_nan.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(
+                       harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+                   std::domain_error, "times");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(
+                       harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+                   std::domain_error, expected_is_nan.str());
 
   std::vector<double> theta_bad = theta;
   theta_bad[0] = nan;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
-      std::domain_error, "parameters and data");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
-      std::domain_error, expected_is_nan.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0, t0, ts,
+                                                         theta_bad, x, x_int)),
+                   std::domain_error, "parameters and data");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0, t0, ts,
+                                                         theta_bad, x, x_int)),
+                   std::domain_error, expected_is_nan.str());
 
   if (x.size() > 0) {
     std::vector<double> x_bad = x;
     x_bad[0] = nan;
-    EXPECT_THROW_MSG(
-		     (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
-        std::domain_error, "parameters and data");
-    EXPECT_THROW_MSG(
-		     (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
-        std::domain_error, expected_is_nan.str());
+    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>,
+                                         std::vector<double>, std::vector<int>>(
+                         harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+                     std::domain_error, "parameters and data");
+    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>,
+                                         std::vector<double>, std::vector<int>>(
+                         harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+                     std::domain_error, expected_is_nan.str());
   }
 }
 
@@ -247,88 +275,110 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions_inf) {
   std::vector<double> x(3, 1);
   std::vector<int> x_int(2, 0);
 
-  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x, x_int)));
+  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                      std::vector<int>>(harm_osc, y0, t0, ts,
+                                                        theta, x, x_int)));
 
   double inf = std::numeric_limits<double>::infinity();
   std::vector<double> y0_bad = y0;
   y0_bad[0] = inf;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
-      std::domain_error, "initial state");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
-      std::domain_error, expected_is_inf.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0_bad, t0,
+                                                         ts, theta, x, x_int)),
+                   std::domain_error, "initial state");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0_bad, t0,
+                                                         ts, theta, x, x_int)),
+                   std::domain_error, expected_is_inf.str());
 
   y0_bad[0] = -inf;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
-      std::domain_error, "initial state");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
-      std::domain_error, expected_is_neg_inf.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0_bad, t0,
+                                                         ts, theta, x, x_int)),
+                   std::domain_error, "initial state");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0_bad, t0,
+                                                         ts, theta, x, x_int)),
+                   std::domain_error, expected_is_neg_inf.str());
 
   double t0_bad = inf;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
-      std::domain_error, "initial time");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
-      std::domain_error, expected_is_inf.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0, t0_bad,
+                                                         ts, theta, x, x_int)),
+                   std::domain_error, "initial time");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0, t0_bad,
+                                                         ts, theta, x, x_int)),
+                   std::domain_error, expected_is_inf.str());
   t0_bad = -inf;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
-      std::domain_error, "initial time");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
-      std::domain_error, expected_is_neg_inf.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0, t0_bad,
+                                                         ts, theta, x, x_int)),
+                   std::domain_error, "initial time");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0, t0_bad,
+                                                         ts, theta, x, x_int)),
+                   std::domain_error, expected_is_neg_inf.str());
 
   std::vector<double> ts_bad = ts;
   ts_bad.push_back(inf);
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-      std::domain_error, "times");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-      std::domain_error, expected_is_inf.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(
+                       harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+                   std::domain_error, "times");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(
+                       harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+                   std::domain_error, expected_is_inf.str());
   ts_bad[0] = -inf;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-      std::domain_error, "times");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-      std::domain_error, expected_is_neg_inf.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(
+                       harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+                   std::domain_error, "times");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(
+                       harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+                   std::domain_error, expected_is_neg_inf.str());
 
   std::vector<double> theta_bad = theta;
   theta_bad[0] = inf;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
-      std::domain_error, "parameters and data");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
-      std::domain_error, expected_is_inf.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0, t0, ts,
+                                                         theta_bad, x, x_int)),
+                   std::domain_error, "parameters and data");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0, t0, ts,
+                                                         theta_bad, x, x_int)),
+                   std::domain_error, expected_is_inf.str());
   theta_bad[0] = -inf;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
-      std::domain_error, "parameters and data");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
-      std::domain_error, expected_is_neg_inf.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0, t0, ts,
+                                                         theta_bad, x, x_int)),
+                   std::domain_error, "parameters and data");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(harm_osc, y0, t0, ts,
+                                                         theta_bad, x, x_int)),
+                   std::domain_error, expected_is_neg_inf.str());
 
   if (x.size() > 0) {
     std::vector<double> x_bad = x;
     x_bad[0] = inf;
-    EXPECT_THROW_MSG(
-		     (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
-        std::domain_error, "parameters and data");
-    EXPECT_THROW_MSG(
-		     (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
-        std::domain_error, expected_is_inf.str());
+    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>,
+                                         std::vector<double>, std::vector<int>>(
+                         harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+                     std::domain_error, "parameters and data");
+    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>,
+                                         std::vector<double>, std::vector<int>>(
+                         harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+                     std::domain_error, expected_is_inf.str());
     x_bad[0] = -inf;
-    EXPECT_THROW_MSG(
-		     (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
-        std::domain_error, "parameters and data");
-    EXPECT_THROW_MSG(
-		     (integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
-        std::domain_error, expected_is_neg_inf.str());
+    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>,
+                                         std::vector<double>, std::vector<int>>(
+                         harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+                     std::domain_error, "parameters and data");
+    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>,
+                                         std::vector<double>, std::vector<int>>(
+                         harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+                     std::domain_error, expected_is_neg_inf.str());
   }
 }
diff --git a/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
index 487cdded308..b5eb9c4e0be 100644
--- a/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
@@ -16,10 +16,11 @@ void sho_value_test(F harm_osc, std::vector<double>& y0, double t0,
   using stan::math::promote_scalar;
   using stan::math::var;
 
-  std::vector<std::vector<var>> ode_res_vd = stan::math::integrate_ode_rk45
-    <std::vector<T_theta>, std::vector<double>, std::vector<int>>
-    (harm_osc, promote_scalar<T_y0>(y0), t0, ts,
-     promote_scalar<T_theta>(theta), x, x_int, 0);
+  std::vector<std::vector<var>> ode_res_vd
+      = stan::math::integrate_ode_rk45<std::vector<T_theta>,
+                                       std::vector<double>, std::vector<int>>(
+          harm_osc, promote_scalar<T_y0>(y0), t0, ts,
+          promote_scalar<T_theta>(theta), x, x_int, 0);
   EXPECT_NEAR(0.995029, ode_res_vd[0][0].val(), 1e-5);
   EXPECT_NEAR(-0.0990884, ode_res_vd[0][1].val(), 1e-5);
 
@@ -140,7 +141,9 @@ TEST(StanAgradRevOde_integrate_ode_rk45, time_steps_as_param) {
   std::vector<std::vector<stan::math::var>> res;
 
   std::vector<std::vector<double>> res_d
-    = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0, t0, value_of(ts), theta, x, x_int);
+      = integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                           std::vector<int>>(ode, y0, t0, value_of(ts), theta,
+                                             x, x_int);
 
   // here we only test first & last steps, and rely on the
   // fact that results in-between affect the initial
@@ -151,21 +154,33 @@ TEST(StanAgradRevOde_integrate_ode_rk45, time_steps_as_param) {
     EXPECT_NEAR(res_d[99][0], res[99][0].val(), 1e-5);
     EXPECT_NEAR(res_d[99][1], res[99][1].val(), 1e-5);
   };
-  res = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0, t0, ts, theta, x, x_int);
+  res = integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                           std::vector<int>>(ode, y0, t0, ts, theta, x, x_int);
   test_val();
-  res = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0v, t0, ts, theta, x, x_int);
+  res = integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                           std::vector<int>>(ode, y0v, t0, ts, theta, x, x_int);
   test_val();
-  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(ode, y0, t0, ts, thetav, x, x_int);
+  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>,
+                           std::vector<int>>(ode, y0, t0, ts, thetav, x, x_int);
   test_val();
-  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(ode, y0v, t0, ts, thetav, x, x_int);
+  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>,
+                           std::vector<int>>(ode, y0v, t0, ts, thetav, x,
+                                             x_int);
   test_val();
-  res = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0, t0v, ts, theta, x, x_int);
+  res = integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                           std::vector<int>>(ode, y0, t0v, ts, theta, x, x_int);
   test_val();
-  res = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0v, t0v, ts, theta, x, x_int);
+  res = integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                           std::vector<int>>(ode, y0v, t0v, ts, theta, x,
+                                             x_int);
   test_val();
-  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(ode, y0, t0v, ts, thetav, x, x_int);
+  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>,
+                           std::vector<int>>(ode, y0, t0v, ts, thetav, x,
+                                             x_int);
   test_val();
-  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(ode, y0v, t0v, ts, thetav, x, x_int);
+  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>,
+                           std::vector<int>>(ode, y0v, t0v, ts, thetav, x,
+                                             x_int);
   test_val();
 }
 
@@ -214,13 +229,18 @@ TEST(StanAgradRevOde_integrate_ode_rk45, time_steps_as_param_AD) {
       }
     }
   };
-  res = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0, t0, ts, theta, x, x_int);
+  res = integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                           std::vector<int>>(ode, y0, t0, ts, theta, x, x_int);
   test_ad();
-  res = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0v, t0, ts, theta, x, x_int);
+  res = integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                           std::vector<int>>(ode, y0v, t0, ts, theta, x, x_int);
   test_ad();
-  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(ode, y0, t0, ts, thetav, x, x_int);
+  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>,
+                           std::vector<int>>(ode, y0, t0, ts, thetav, x, x_int);
   test_ad();
-  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(ode, y0v, t0, ts, thetav, x, x_int);
+  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>,
+                           std::vector<int>>(ode, y0v, t0, ts, thetav, x,
+                                             x_int);
   test_ad();
 }
 
@@ -259,12 +279,19 @@ TEST(StanAgradRevOde_integrate_ode_rk45, t0_as_param_AD) {
       }
     }
   };
-  res = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0, t0v, ts, theta, x, x_int);
+  res = integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                           std::vector<int>>(ode, y0, t0v, ts, theta, x, x_int);
   test_ad();
-  res = integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(ode, y0v, t0v, ts, theta, x, x_int);
+  res = integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                           std::vector<int>>(ode, y0v, t0v, ts, theta, x,
+                                             x_int);
   test_ad();
-  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(ode, y0, t0v, ts, thetav, x, x_int);
+  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>,
+                           std::vector<int>>(ode, y0, t0v, ts, thetav, x,
+                                             x_int);
   test_ad();
-  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(ode, y0v, t0v, ts, thetav, x, x_int);
+  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>,
+                           std::vector<int>>(ode, y0v, t0v, ts, thetav, x,
+                                             x_int);
   test_ad();
 }
diff --git a/test/unit/math/rev/functor/util.hpp b/test/unit/math/rev/functor/util.hpp
index 425a4c897f2..14ebfb52d5c 100644
--- a/test/unit/math/rev/functor/util.hpp
+++ b/test/unit/math/rev/functor/util.hpp
@@ -8,7 +8,7 @@
 
 // calculates finite diffs for integrate_ode_rk45 with varying parameters
 template <typename F>
-std::vector<std::vector<double> > finite_diff_params(
+std::vector<std::vector<double>> finite_diff_params(
     const F& f, const double& t_in, const std::vector<double>& ts,
     const std::vector<double>& y_in, const std::vector<double>& theta,
     const std::vector<double>& x, const std::vector<int>& x_int,
@@ -26,15 +26,19 @@ std::vector<std::vector<double> > finite_diff_params(
     }
   }
 
-  std::vector<std::vector<double> > ode_res_ub;
-  std::vector<std::vector<double> > ode_res_lb;
+  std::vector<std::vector<double>> ode_res_ub;
+  std::vector<std::vector<double>> ode_res_lb;
 
-  ode_res_ub = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(f, y_in, t_in, ts, theta_ub, x,
-                                              x_int, &msgs);
-  ode_res_lb = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(f, y_in, t_in, ts, theta_lb, x,
-                                              x_int, &msgs);
+  ode_res_ub
+      = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(
+          f, y_in, t_in, ts, theta_ub, x, x_int, &msgs);
+  ode_res_lb
+      = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(
+          f, y_in, t_in, ts, theta_lb, x, x_int, &msgs);
 
-  std::vector<std::vector<double> > results(ts.size());
+  std::vector<std::vector<double>> results(ts.size());
 
   for (size_t i = 0; i < ode_res_ub.size(); i++)
     for (size_t j = 0; j < ode_res_ub[j].size(); j++)
@@ -44,7 +48,7 @@ std::vector<std::vector<double> > finite_diff_params(
 
 // calculates finite diffs for integrate_ode_rk45 with varying initial positions
 template <typename F>
-std::vector<std::vector<double> > finite_diff_initial_position(
+std::vector<std::vector<double>> finite_diff_initial_position(
     const F& f, const double& t_in, const std::vector<double>& ts,
     const std::vector<double>& y_in, const std::vector<double>& theta,
     const std::vector<double>& x, const std::vector<int>& x_int,
@@ -62,15 +66,19 @@ std::vector<std::vector<double> > finite_diff_initial_position(
     }
   }
 
-  std::vector<std::vector<double> > ode_res_ub;
-  std::vector<std::vector<double> > ode_res_lb;
+  std::vector<std::vector<double>> ode_res_ub;
+  std::vector<std::vector<double>> ode_res_lb;
 
-  ode_res_ub = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(f, y_in_ub, t_in, ts, theta, x,
-                                              x_int, &msgs);
-  ode_res_lb = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(f, y_in_lb, t_in, ts, theta, x,
-                                              x_int, &msgs);
+  ode_res_ub
+      = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(
+          f, y_in_ub, t_in, ts, theta, x, x_int, &msgs);
+  ode_res_lb
+      = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(
+          f, y_in_lb, t_in, ts, theta, x, x_int, &msgs);
 
-  std::vector<std::vector<double> > results(ts.size());
+  std::vector<std::vector<double>> results(ts.size());
 
   for (size_t i = 0; i < ode_res_ub.size(); i++)
     for (size_t j = 0; j < ode_res_ub[j].size(); j++)
@@ -90,7 +98,7 @@ void test_ode_finite_diff_dv(const F& f, const double& t_in,
                              const double& diff2) {
   std::stringstream msgs;
 
-  std::vector<std::vector<std::vector<double> > > finite_diff_res(theta.size());
+  std::vector<std::vector<std::vector<double>>> finite_diff_res(theta.size());
   for (size_t i = 0; i < theta.size(); i++)
     finite_diff_res[i]
         = finite_diff_params(f, t_in, ts, y_in, theta, x, x_int, i, diff);
@@ -101,10 +109,12 @@ void test_ode_finite_diff_dv(const F& f, const double& t_in,
   for (size_t i = 0; i < theta.size(); i++)
     theta_v.push_back(theta[i]);
 
-  std::vector<std::vector<stan::math::var> > ode_res;
+  std::vector<std::vector<stan::math::var>> ode_res;
 
-  ode_res = stan::math::integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(f, y_in, t_in, ts, theta_v, x, x_int,
-                                           &msgs);
+  ode_res
+      = stan::math::integrate_ode_rk45<std::vector<stan::math::var>,
+                                       std::vector<double>, std::vector<int>>(
+          f, y_in, t_in, ts, theta_v, x, x_int, &msgs);
 
   for (size_t i = 0; i < ts.size(); i++) {
     for (size_t j = 0; j < y_in.size(); j++) {
@@ -134,7 +144,7 @@ void test_ode_finite_diff_vd(const F& f, const double& t_in,
                              const double& diff2) {
   std::stringstream msgs;
 
-  std::vector<std::vector<std::vector<double> > > finite_diff_res(y_in.size());
+  std::vector<std::vector<std::vector<double>>> finite_diff_res(y_in.size());
   for (size_t i = 0; i < y_in.size(); i++)
     finite_diff_res[i] = finite_diff_initial_position(f, t_in, ts, y_in, theta,
                                                       x, x_int, i, diff);
@@ -145,10 +155,12 @@ void test_ode_finite_diff_vd(const F& f, const double& t_in,
   for (size_t k = 0; k < y_in.size(); k++)
     y_in_v.push_back(y_in[k]);
 
-  std::vector<std::vector<stan::math::var> > ode_res;
+  std::vector<std::vector<stan::math::var>> ode_res;
 
-  ode_res = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>, std::vector<int>>(f, y_in_v, t_in, ts, theta, x, x_int,
-                                           &msgs);
+  ode_res
+      = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>,
+                                       std::vector<int>>(
+          f, y_in_v, t_in, ts, theta, x, x_int, &msgs);
 
   for (size_t i = 0; i < ts.size(); i++) {
     for (size_t j = 0; j < y_in.size(); j++) {
@@ -178,14 +190,12 @@ void test_ode_finite_diff_vv(const F& f, const double& t_in,
                              const double& diff2) {
   std::stringstream msgs;
 
-  std::vector<std::vector<std::vector<double> > > finite_diff_res_y(
-      y_in.size());
+  std::vector<std::vector<std::vector<double>>> finite_diff_res_y(y_in.size());
   for (size_t i = 0; i < y_in.size(); i++)
     finite_diff_res_y[i] = finite_diff_initial_position(
         f, t_in, ts, y_in, theta, x, x_int, i, diff);
 
-  std::vector<std::vector<std::vector<double> > > finite_diff_res_p(
-      theta.size());
+  std::vector<std::vector<std::vector<double>>> finite_diff_res_p(theta.size());
   for (size_t i = 0; i < theta.size(); i++)
     finite_diff_res_p[i]
         = finite_diff_params(f, t_in, ts, y_in, theta, x, x_int, i, diff);
@@ -204,10 +214,12 @@ void test_ode_finite_diff_vv(const F& f, const double& t_in,
   for (size_t i = 0; i < theta_v.size(); i++)
     vars.push_back(theta_v[i]);
 
-  std::vector<std::vector<stan::math::var> > ode_res;
+  std::vector<std::vector<stan::math::var>> ode_res;
 
-  ode_res = stan::math::integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>, std::vector<int>>(f, y_in_v, t_in, ts, theta_v, x,
-                                           x_int, &msgs);
+  ode_res
+      = stan::math::integrate_ode_rk45<std::vector<stan::math::var>,
+                                       std::vector<double>, std::vector<int>>(
+          f, y_in_v, t_in, ts, theta_v, x, x_int, &msgs);
 
   for (size_t i = 0; i < ts.size(); i++) {
     for (size_t j = 0; j < y_in.size(); j++) {
@@ -242,14 +254,17 @@ void test_ode_error_conditions(F& f, const double& t0,
   using stan::math::integrate_ode_rk45;
   std::stringstream msgs;
 
-  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x, x_int, 0)));
+  ASSERT_NO_THROW((
+      integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                         std::vector<int>>(f, y0, t0, ts, theta, x, x_int, 0)));
   ASSERT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T1> y0_bad;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
-      std::invalid_argument, "initial state has size 0");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
+                   std::invalid_argument, "initial state has size 0");
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
@@ -257,48 +272,54 @@ void test_ode_error_conditions(F& f, const double& t0,
   std::stringstream expected_msg;
   expected_msg << "initial time is " << t0_bad << ", but must be less than "
                << ts[0];
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
-      std::domain_error, expected_msg.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
+                   std::domain_error, expected_msg.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<double> ts_bad;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-      std::invalid_argument, "times has size 0");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
+                   std::invalid_argument, "times has size 0");
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   ts_bad.push_back(3);
   ts_bad.push_back(1);
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-      std::domain_error, "times is not a valid ordered vector");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
+                   std::domain_error, "times is not a valid ordered vector");
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T2> theta_bad;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
-      std::out_of_range, "vector");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+                   std::out_of_range, "vector");
   EXPECT_EQ("", msgs.str());
 
   if (x.size() > 0) {
     msgs.clear();
     std::vector<double> x_bad;
-    EXPECT_THROW_MSG(
-		     (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
-        std::out_of_range, "vector");
+    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                         std::vector<int>>(
+                         f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+                     std::out_of_range, "vector");
     EXPECT_EQ("", msgs.str());
   }
 
   if (x_int.size() > 0) {
     msgs.clear();
     std::vector<int> x_int_bad;
-    EXPECT_THROW_MSG(
-		     (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x, x_int_bad, &msgs)),
-        std::out_of_range, "vector");
+    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                         std::vector<int>>(
+                         f, y0, t0, ts, theta, x, x_int_bad, &msgs)),
+                     std::out_of_range, "vector");
     EXPECT_EQ("", msgs.str());
   }
 }
@@ -316,62 +337,74 @@ void test_ode_error_conditions_nan(F& f, const double& t0,
   std::stringstream expected_is_nan;
   expected_is_nan << "is " << nan;
 
-  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x, x_int, 0)));
+  ASSERT_NO_THROW((
+      integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                         std::vector<int>>(f, y0, t0, ts, theta, x, x_int, 0)));
   ASSERT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T1> y0_bad = y0;
   y0_bad[0] = nan;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
-      std::domain_error, "initial state");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
-      std::domain_error, expected_is_nan.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
+                   std::domain_error, "initial state");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
+                   std::domain_error, expected_is_nan.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   double t0_bad = nan;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
-      std::domain_error, "initial time");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
-      std::domain_error, expected_is_nan.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
+                   std::domain_error, "initial time");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
+                   std::domain_error, expected_is_nan.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<double> ts_bad = ts;
   ts_bad[0] = nan;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-      std::domain_error, "times");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-      std::domain_error, expected_is_nan.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
+                   std::domain_error, "times");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
+                   std::domain_error, expected_is_nan.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T2> theta_bad = theta;
   theta_bad[0] = nan;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
-      std::domain_error, "ode parameters and data");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
-      std::domain_error, expected_is_nan.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+                   std::domain_error, "ode parameters and data");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+                   std::domain_error, expected_is_nan.str());
   EXPECT_EQ("", msgs.str());
 
   if (x.size() > 0) {
     msgs.clear();
     std::vector<double> x_bad = x;
     x_bad[0] = nan;
-    EXPECT_THROW_MSG(
-		     (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
-        std::domain_error, "ode parameters and data");
-    EXPECT_THROW_MSG(
-		     (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
-        std::domain_error, expected_is_nan.str());
+    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                         std::vector<int>>(
+                         f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+                     std::domain_error, "ode parameters and data");
+    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                         std::vector<int>>(
+                         f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+                     std::domain_error, expected_is_nan.str());
     EXPECT_EQ("", msgs.str());
   }
 }
@@ -391,97 +424,119 @@ void test_ode_error_conditions_inf(F& f, const double& t0,
   std::stringstream expected_is_neg_inf;
   expected_is_neg_inf << "is " << -inf;
 
-  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x, x_int, 0)));
+  ASSERT_NO_THROW((
+      integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                         std::vector<int>>(f, y0, t0, ts, theta, x, x_int, 0)));
   ASSERT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T1> y0_bad = y0;
   y0_bad[0] = inf;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
-      std::domain_error, "initial state");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
-      std::domain_error, expected_is_inf.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
+                   std::domain_error, "initial state");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
+                   std::domain_error, expected_is_inf.str());
   y0_bad[0] = -inf;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
-      std::domain_error, "initial state");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
-      std::domain_error, expected_is_neg_inf.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
+                   std::domain_error, "initial state");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
+                   std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   double t0_bad = inf;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
-      std::domain_error, "initial time");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
-      std::domain_error, expected_is_inf.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
+                   std::domain_error, "initial time");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
+                   std::domain_error, expected_is_inf.str());
   t0_bad = -inf;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
-      std::domain_error, "initial time");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
-      std::domain_error, expected_is_neg_inf.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
+                   std::domain_error, "initial time");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
+                   std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<double> ts_bad = ts;
   ts_bad[0] = inf;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-      std::domain_error, "times");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-      std::domain_error, expected_is_inf.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
+                   std::domain_error, "times");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
+                   std::domain_error, expected_is_inf.str());
   ts_bad[0] = -inf;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-      std::domain_error, "times");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-      std::domain_error, expected_is_neg_inf.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
+                   std::domain_error, "times");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
+                   std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T2> theta_bad = theta;
   theta_bad[0] = inf;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
-      std::domain_error, "ode parameters and data");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
-      std::domain_error, expected_is_inf.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+                   std::domain_error, "ode parameters and data");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+                   std::domain_error, expected_is_inf.str());
   theta_bad[0] = -inf;
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
-      std::domain_error, "ode parameters and data");
-  EXPECT_THROW_MSG(
-		   (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
-      std::domain_error, expected_is_neg_inf.str());
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+                   std::domain_error, "ode parameters and data");
+  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                       std::vector<int>>(
+                       f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+                   std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
 
   if (x.size() > 0) {
     msgs.clear();
     std::vector<double> x_bad = x;
     x_bad[0] = inf;
-    EXPECT_THROW_MSG(
-		     (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
-        std::domain_error, "ode parameters and data");
-    EXPECT_THROW_MSG(
-		     (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
-        std::domain_error, expected_is_inf.str());
+    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                         std::vector<int>>(
+                         f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+                     std::domain_error, "ode parameters and data");
+    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                         std::vector<int>>(
+                         f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+                     std::domain_error, expected_is_inf.str());
     x_bad[0] = -inf;
-    EXPECT_THROW_MSG(
-		     (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
-        std::domain_error, "ode parameters and data");
-    EXPECT_THROW_MSG(
-		     (integrate_ode_rk45<std::vector<T2>, std::vector<double>, std::vector<int>>(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
-        std::domain_error, expected_is_neg_inf.str());
+    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                         std::vector<int>>(
+                         f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+                     std::domain_error, "ode parameters and data");
+    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
+                                         std::vector<int>>(
+                         f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+                     std::domain_error, expected_is_neg_inf.str());
     EXPECT_EQ("", msgs.str());
   }
 }
@@ -543,4 +598,3 @@ void test_ode(const F& f, const double& t_in, const std::vector<double>& ts,
   test_ode_error_conditions_dv(f, t_in, ts, y_in, theta, x, x_int);
   test_ode_error_conditions_vv(f, t_in, ts, y_in, theta, x, x_int);
 }
-

From 94989a0302c7e34f6030aef7cb5a73f5716ff662 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Fri, 31 Jan 2020 17:14:56 -0500
Subject: [PATCH 077/189] Fixed off by one error on start/end indices passed by
 reduce_sum to user function

Added extra template conditions for accumulate_adjoints_, count_vars_impl_, save_varis_ to avoid ambiguity
---
 stan/math/prim/functor/reduce_sum.hpp         |  4 +--
 stan/math/rev/functor/reduce_sum.hpp          |  5 +++-
 .../unit/math/mix/functor/reduce_sum_test.cpp | 26 +++++++++++++++++++
 .../math/prim/functor/reduce_sum_test.cpp     | 23 ++++++++++++++++
 .../unit/math/rev/functor/reduce_sum_test.cpp |  6 ++---
 5 files changed, 58 insertions(+), 6 deletions(-)

diff --git a/stan/math/prim/functor/reduce_sum.hpp b/stan/math/prim/functor/reduce_sum.hpp
index 890c53cb8c7..c784ad5461c 100644
--- a/stan/math/prim/functor/reduce_sum.hpp
+++ b/stan/math/prim/functor/reduce_sum.hpp
@@ -32,7 +32,7 @@ struct reduce_sum_impl {
     if (num_jobs == 0)
       return 0.0;
 
-    return ReduceFunction()(0, vmapped.size() - 1, vmapped, msgs, args...);
+    return ReduceFunction()(1, vmapped.size(), vmapped, msgs, args...);
   }
 };
 
@@ -71,7 +71,7 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
 
       sum_ += apply(
           [&](auto&&... args) {
-            return ReduceFunction()(r.begin(), r.end() - 1, sub_slice, msgs_,
+            return ReduceFunction()(r.begin() + 1, r.end(), sub_slice, msgs_,
                                     args...);
           },
           args_tuple_);
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 80acb306e5b..36fecc96a7a 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -80,6 +80,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   template <typename T, require_t<is_var<scalar_type_t<T>>>...,
+	    require_not_t<is_var<T>>...,
             typename... Pargs>
   static double* accumulate_adjoints(double* dest, const std::vector<T>& x,
                                      const Pargs&... args) {
@@ -164,7 +165,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
 
         var sub_sum_v = apply(
             [&](auto&&... args) {
-              return ReduceFunction()(r.begin(), r.end() - 1, local_sub_slice,
+              return ReduceFunction()(r.begin() + 1, r.end(), local_sub_slice,
                                       msgs_, args...);
             },
             args_tuple_local_copy);
@@ -204,6 +205,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   template <typename T, require_t<is_var<scalar_type_t<T>>>...,
+	    require_not_t<is_var<T>>...,
             typename... Pargs>
   size_t count_var_impl(size_t count, const std::vector<T>& x,
                         const Pargs&... args) const {
@@ -260,6 +262,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   template <typename T, require_t<is_var<scalar_type_t<T>>>...,
+	    require_not_t<is_var<T>>...,
             typename... Pargs>
   vari** save_varis(vari** dest, const std::vector<T>& x,
                     const Pargs&... args) const {
diff --git a/test/unit/math/mix/functor/reduce_sum_test.cpp b/test/unit/math/mix/functor/reduce_sum_test.cpp
index 27815db29be..4de5ebada0b 100644
--- a/test/unit/math/mix/functor/reduce_sum_test.cpp
+++ b/test/unit/math/mix/functor/reduce_sum_test.cpp
@@ -47,6 +47,32 @@ TEST(MathMix_reduce_sum, double_slice) {
   stan::test::expect_ad(f, data);
 }
 
+struct start_end_lpdf {
+  template <typename T>
+  inline auto operator()(std::size_t start, std::size_t end,
+                         const std::vector<T>&,
+                         std::ostream* msgs,
+			 const std::vector<T>& data) const {
+    T sum = 0;
+    EXPECT_GE(start, 1);
+    EXPECT_LE(end, data.size());
+    for(size_t i = start - 1; i < end; i++) {
+      sum += data[i];
+    }
+    return sum;
+  }
+};
+
+TEST(StanMath_reduce_sum, start_end_slice) {
+  auto start_end = [](const auto& arg) {
+    return stan::math::reduce_sum<start_end_lpdf>(arg, 0, msgs, arg);
+  };
+
+  std::vector<double> data(5, 1.0);
+
+  stan::test::expect_ad(start_end, data);
+}
+
 auto fi = [](const auto&... args) {
   return stan::math::reduce_sum<sum_lpdf>(std::vector<int>(2, 10.0), 0, msgs,
                                           args...);
diff --git a/test/unit/math/prim/functor/reduce_sum_test.cpp b/test/unit/math/prim/functor/reduce_sum_test.cpp
index 55d690d5099..c1dc6ce38fb 100644
--- a/test/unit/math/prim/functor/reduce_sum_test.cpp
+++ b/test/unit/math/prim/functor/reduce_sum_test.cpp
@@ -122,6 +122,29 @@ TEST(StanMath_reduce_sum, double_slice) {
                    stan::math::reduce_sum<double_slice_lpdf>(data, 0, msgs));
 }
 
+struct start_end_lpdf {
+  inline auto operator()(std::size_t start, std::size_t end,
+                         const std::vector<int>&,
+                         std::ostream* msgs,
+			 const std::vector<int>& data) const {
+    int sum = 0;
+    EXPECT_GE(start, 1);
+    EXPECT_LE(end, data.size());
+    for(size_t i = start - 1; i < end; i++) {
+      sum += data[i];
+    }
+    return sum;
+  }
+};
+
+TEST(StanMath_reduce_sum, start_end_slice) {
+  stan::math::init_threadpool_tbb();
+
+  std::vector<int> data(5, 10);
+
+  EXPECT_EQ(50, stan::math::reduce_sum<start_end_lpdf>(data, 0, msgs, data));
+}
+
 struct int_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
diff --git a/test/unit/math/rev/functor/reduce_sum_test.cpp b/test/unit/math/rev/functor/reduce_sum_test.cpp
index 9054d61c3ef..0d9390fd583 100644
--- a/test/unit/math/rev/functor/reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/reduce_sum_test.cpp
@@ -182,7 +182,7 @@ struct grouped_count_lpdf {
     // num_terms << "; size = " << sub_slice.size() << std::endl;
     VecT lambda_slice(num_terms);
     for (std::size_t i = 0; i != num_terms; ++i)
-      lambda_slice[i] = lambda[gidx[start + i]];
+      lambda_slice[i] = lambda[gidx[start + i - 1]];
 
     return stan::math::poisson_lpmf(sub_slice, lambda_slice);
   }
@@ -321,8 +321,8 @@ struct slice_group_count_lpdf {
     const std::size_t num_groups = end - start + 1;
     T result = 0.0;
     for (std::size_t i = 0; i != num_groups; ++i) {
-      std::vector<int> y_group(y.begin() + gsidx[start + i],
-                               y.begin() + gsidx[start + i + 1]);
+      std::vector<int> y_group(y.begin() + gsidx[start + i - 1],
+                               y.begin() + gsidx[start + i]);
       result += stan::math::poisson_lpmf(y_group, lambda_slice[i]);
     }
     return result;

From 70546f47aa3bb8a945b6693052ef5f16938fda26 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 31 Jan 2020 22:19:36 +0000
Subject: [PATCH 078/189] [Jenkins] auto-formatting by clang-format version
 5.0.0-3~16.04.1 (tags/RELEASE_500/final)

---
 stan/math/rev/functor/reduce_sum.hpp            | 9 +++------
 test/unit/math/mix/functor/reduce_sum_test.cpp  | 7 +++----
 test/unit/math/prim/functor/reduce_sum_test.cpp | 7 +++----
 3 files changed, 9 insertions(+), 14 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 36fecc96a7a..7da091171bb 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -80,8 +80,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   template <typename T, require_t<is_var<scalar_type_t<T>>>...,
-	    require_not_t<is_var<T>>...,
-            typename... Pargs>
+            require_not_t<is_var<T>>..., typename... Pargs>
   static double* accumulate_adjoints(double* dest, const std::vector<T>& x,
                                      const Pargs&... args) {
     for (size_t i = 0; i < x.size(); ++i) {
@@ -205,8 +204,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   template <typename T, require_t<is_var<scalar_type_t<T>>>...,
-	    require_not_t<is_var<T>>...,
-            typename... Pargs>
+            require_not_t<is_var<T>>..., typename... Pargs>
   size_t count_var_impl(size_t count, const std::vector<T>& x,
                         const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); i++) {
@@ -262,8 +260,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   template <typename T, require_t<is_var<scalar_type_t<T>>>...,
-	    require_not_t<is_var<T>>...,
-            typename... Pargs>
+            require_not_t<is_var<T>>..., typename... Pargs>
   vari** save_varis(vari** dest, const std::vector<T>& x,
                     const Pargs&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
diff --git a/test/unit/math/mix/functor/reduce_sum_test.cpp b/test/unit/math/mix/functor/reduce_sum_test.cpp
index 4de5ebada0b..732824ac16c 100644
--- a/test/unit/math/mix/functor/reduce_sum_test.cpp
+++ b/test/unit/math/mix/functor/reduce_sum_test.cpp
@@ -50,13 +50,12 @@ TEST(MathMix_reduce_sum, double_slice) {
 struct start_end_lpdf {
   template <typename T>
   inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<T>&,
-                         std::ostream* msgs,
-			 const std::vector<T>& data) const {
+                         const std::vector<T>&, std::ostream* msgs,
+                         const std::vector<T>& data) const {
     T sum = 0;
     EXPECT_GE(start, 1);
     EXPECT_LE(end, data.size());
-    for(size_t i = start - 1; i < end; i++) {
+    for (size_t i = start - 1; i < end; i++) {
       sum += data[i];
     }
     return sum;
diff --git a/test/unit/math/prim/functor/reduce_sum_test.cpp b/test/unit/math/prim/functor/reduce_sum_test.cpp
index c1dc6ce38fb..ddc0f43c83d 100644
--- a/test/unit/math/prim/functor/reduce_sum_test.cpp
+++ b/test/unit/math/prim/functor/reduce_sum_test.cpp
@@ -124,13 +124,12 @@ TEST(StanMath_reduce_sum, double_slice) {
 
 struct start_end_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<int>&,
-                         std::ostream* msgs,
-			 const std::vector<int>& data) const {
+                         const std::vector<int>&, std::ostream* msgs,
+                         const std::vector<int>& data) const {
     int sum = 0;
     EXPECT_GE(start, 1);
     EXPECT_LE(end, data.size());
-    for(size_t i = start - 1; i < end; i++) {
+    for (size_t i = start - 1; i < end; i++) {
       sum += data[i];
     }
     return sum;

From 4cfcfe81bb2f0886f4892145371aca419a32a389 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Fri, 31 Jan 2020 17:38:41 -0500
Subject: [PATCH 079/189] Revert "Fixed off by one error on start/end indices
 passed by reduce_sum to user function"

This reverts commit 94989a0302c7e34f6030aef7cb5a73f5716ff662.
---
 stan/math/prim/functor/reduce_sum.hpp         |  4 +--
 stan/math/rev/functor/reduce_sum.hpp          |  5 +---
 .../unit/math/mix/functor/reduce_sum_test.cpp | 26 -------------------
 .../math/prim/functor/reduce_sum_test.cpp     | 23 ----------------
 .../unit/math/rev/functor/reduce_sum_test.cpp |  6 ++---
 5 files changed, 6 insertions(+), 58 deletions(-)

diff --git a/stan/math/prim/functor/reduce_sum.hpp b/stan/math/prim/functor/reduce_sum.hpp
index c784ad5461c..890c53cb8c7 100644
--- a/stan/math/prim/functor/reduce_sum.hpp
+++ b/stan/math/prim/functor/reduce_sum.hpp
@@ -32,7 +32,7 @@ struct reduce_sum_impl {
     if (num_jobs == 0)
       return 0.0;
 
-    return ReduceFunction()(1, vmapped.size(), vmapped, msgs, args...);
+    return ReduceFunction()(0, vmapped.size() - 1, vmapped, msgs, args...);
   }
 };
 
@@ -71,7 +71,7 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
 
       sum_ += apply(
           [&](auto&&... args) {
-            return ReduceFunction()(r.begin() + 1, r.end(), sub_slice, msgs_,
+            return ReduceFunction()(r.begin(), r.end() - 1, sub_slice, msgs_,
                                     args...);
           },
           args_tuple_);
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 36fecc96a7a..80acb306e5b 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -80,7 +80,6 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   template <typename T, require_t<is_var<scalar_type_t<T>>>...,
-	    require_not_t<is_var<T>>...,
             typename... Pargs>
   static double* accumulate_adjoints(double* dest, const std::vector<T>& x,
                                      const Pargs&... args) {
@@ -165,7 +164,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
 
         var sub_sum_v = apply(
             [&](auto&&... args) {
-              return ReduceFunction()(r.begin() + 1, r.end(), local_sub_slice,
+              return ReduceFunction()(r.begin(), r.end() - 1, local_sub_slice,
                                       msgs_, args...);
             },
             args_tuple_local_copy);
@@ -205,7 +204,6 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   template <typename T, require_t<is_var<scalar_type_t<T>>>...,
-	    require_not_t<is_var<T>>...,
             typename... Pargs>
   size_t count_var_impl(size_t count, const std::vector<T>& x,
                         const Pargs&... args) const {
@@ -262,7 +260,6 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   template <typename T, require_t<is_var<scalar_type_t<T>>>...,
-	    require_not_t<is_var<T>>...,
             typename... Pargs>
   vari** save_varis(vari** dest, const std::vector<T>& x,
                     const Pargs&... args) const {
diff --git a/test/unit/math/mix/functor/reduce_sum_test.cpp b/test/unit/math/mix/functor/reduce_sum_test.cpp
index 4de5ebada0b..27815db29be 100644
--- a/test/unit/math/mix/functor/reduce_sum_test.cpp
+++ b/test/unit/math/mix/functor/reduce_sum_test.cpp
@@ -47,32 +47,6 @@ TEST(MathMix_reduce_sum, double_slice) {
   stan::test::expect_ad(f, data);
 }
 
-struct start_end_lpdf {
-  template <typename T>
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<T>&,
-                         std::ostream* msgs,
-			 const std::vector<T>& data) const {
-    T sum = 0;
-    EXPECT_GE(start, 1);
-    EXPECT_LE(end, data.size());
-    for(size_t i = start - 1; i < end; i++) {
-      sum += data[i];
-    }
-    return sum;
-  }
-};
-
-TEST(StanMath_reduce_sum, start_end_slice) {
-  auto start_end = [](const auto& arg) {
-    return stan::math::reduce_sum<start_end_lpdf>(arg, 0, msgs, arg);
-  };
-
-  std::vector<double> data(5, 1.0);
-
-  stan::test::expect_ad(start_end, data);
-}
-
 auto fi = [](const auto&... args) {
   return stan::math::reduce_sum<sum_lpdf>(std::vector<int>(2, 10.0), 0, msgs,
                                           args...);
diff --git a/test/unit/math/prim/functor/reduce_sum_test.cpp b/test/unit/math/prim/functor/reduce_sum_test.cpp
index c1dc6ce38fb..55d690d5099 100644
--- a/test/unit/math/prim/functor/reduce_sum_test.cpp
+++ b/test/unit/math/prim/functor/reduce_sum_test.cpp
@@ -122,29 +122,6 @@ TEST(StanMath_reduce_sum, double_slice) {
                    stan::math::reduce_sum<double_slice_lpdf>(data, 0, msgs));
 }
 
-struct start_end_lpdf {
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<int>&,
-                         std::ostream* msgs,
-			 const std::vector<int>& data) const {
-    int sum = 0;
-    EXPECT_GE(start, 1);
-    EXPECT_LE(end, data.size());
-    for(size_t i = start - 1; i < end; i++) {
-      sum += data[i];
-    }
-    return sum;
-  }
-};
-
-TEST(StanMath_reduce_sum, start_end_slice) {
-  stan::math::init_threadpool_tbb();
-
-  std::vector<int> data(5, 10);
-
-  EXPECT_EQ(50, stan::math::reduce_sum<start_end_lpdf>(data, 0, msgs, data));
-}
-
 struct int_arg_lpdf {
   inline auto operator()(std::size_t start, std::size_t end,
                          const std::vector<double>& sub_slice,
diff --git a/test/unit/math/rev/functor/reduce_sum_test.cpp b/test/unit/math/rev/functor/reduce_sum_test.cpp
index 0d9390fd583..9054d61c3ef 100644
--- a/test/unit/math/rev/functor/reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/reduce_sum_test.cpp
@@ -182,7 +182,7 @@ struct grouped_count_lpdf {
     // num_terms << "; size = " << sub_slice.size() << std::endl;
     VecT lambda_slice(num_terms);
     for (std::size_t i = 0; i != num_terms; ++i)
-      lambda_slice[i] = lambda[gidx[start + i - 1]];
+      lambda_slice[i] = lambda[gidx[start + i]];
 
     return stan::math::poisson_lpmf(sub_slice, lambda_slice);
   }
@@ -321,8 +321,8 @@ struct slice_group_count_lpdf {
     const std::size_t num_groups = end - start + 1;
     T result = 0.0;
     for (std::size_t i = 0; i != num_groups; ++i) {
-      std::vector<int> y_group(y.begin() + gsidx[start + i - 1],
-                               y.begin() + gsidx[start + i]);
+      std::vector<int> y_group(y.begin() + gsidx[start + i],
+                               y.begin() + gsidx[start + i + 1]);
       result += stan::math::poisson_lpmf(y_group, lambda_slice[i]);
     }
     return result;

From d46c0224125b386e26d17bddb0a3a7e272868f99 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Fri, 31 Jan 2020 17:41:31 -0500
Subject: [PATCH 080/189] Added extra template conditions for
 accumulate_adjoints_, count_vars_impl_, save_varis_ to avoid ambiguity

---
 stan/math/rev/functor/reduce_sum.hpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 80acb306e5b..46352d1f5d8 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -80,6 +80,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   template <typename T, require_t<is_var<scalar_type_t<T>>>...,
+	    require_not_t<is_var<T>>...,
             typename... Pargs>
   static double* accumulate_adjoints(double* dest, const std::vector<T>& x,
                                      const Pargs&... args) {
@@ -204,6 +205,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   template <typename T, require_t<is_var<scalar_type_t<T>>>...,
+	    require_not_t<is_var<T>>...,
             typename... Pargs>
   size_t count_var_impl(size_t count, const std::vector<T>& x,
                         const Pargs&... args) const {
@@ -260,6 +262,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   template <typename T, require_t<is_var<scalar_type_t<T>>>...,
+	    require_not_t<is_var<T>>...,
             typename... Pargs>
   vari** save_varis(vari** dest, const std::vector<T>& x,
                     const Pargs&... args) const {

From 87a86ea67cdb3d25d5f925833b3adcc1023f1c06 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Wed, 5 Feb 2020 11:42:48 -0500
Subject: [PATCH 081/189] Absorbed cvodes_ode_data.hpp stuff into
 cvodes_integrator.hpp

Moved cvodes_ode_observer.hpp stuff into coupled_ode_system.hpp

Moved rk45 integrator back to prim
---
 stan/math/prim/functor.hpp                    |   2 +
 stan/math/prim/functor/coupled_ode_system.hpp | 151 +++++++++
 .../functor/integrate_ode_rk45.hpp            |  19 +-
 stan/math/rev/functor.hpp                     |   3 -
 .../math/rev/functor/coupled_ode_observer.hpp | 171 ----------
 stan/math/rev/functor/coupled_ode_system.hpp  |  85 +++--
 stan/math/rev/functor/cvodes_integrator.hpp   | 291 +++++++++++++-----
 stan/math/rev/functor/cvodes_ode_data.hpp     | 196 ------------
 stan/math/rev/functor/integrate_ode_adams.hpp |  11 +-
 stan/math/rev/functor/integrate_ode_bdf.hpp   |  13 +-
 .../functor/integrate_ode_rk45_prim_test.cpp  |   2 +-
 .../functor/integrate_ode_adams_prim_test.cpp |  18 +-
 .../functor/integrate_ode_bdf_prim_test.cpp   |   6 +-
 .../math/rev/functor/util_cvodes_adams.hpp    |  12 +-
 14 files changed, 471 insertions(+), 509 deletions(-)
 create mode 100644 stan/math/prim/functor/coupled_ode_system.hpp
 rename stan/math/{rev => prim}/functor/integrate_ode_rk45.hpp (91%)
 delete mode 100644 stan/math/rev/functor/coupled_ode_observer.hpp
 delete mode 100644 stan/math/rev/functor/cvodes_ode_data.hpp
 rename test/unit/math/{rev => prim}/functor/integrate_ode_rk45_prim_test.cpp (99%)

diff --git a/stan/math/prim/functor.hpp b/stan/math/prim/functor.hpp
index 80eb8555642..7ca08d66260 100644
--- a/stan/math/prim/functor.hpp
+++ b/stan/math/prim/functor.hpp
@@ -2,12 +2,14 @@
 #define STAN_MATH_PRIM_FUNCTOR_HPP
 
 #include <stan/math/prim/functor/apply.hpp>
+#include <stan/math/prim/functor/coupled_ode_system.hpp>
 #include <stan/math/prim/functor/finite_diff_gradient.hpp>
 #include <stan/math/prim/functor/finite_diff_gradient_auto.hpp>
 #include <stan/math/prim/functor/finite_diff_hessian.hpp>
 #include <stan/math/prim/functor/finite_diff_hessian_auto.hpp>
 #include <stan/math/prim/functor/finite_diff_hessian_helper.hpp>
 #include <stan/math/prim/functor/integrate_1d.hpp>
+#include <stan/math/prim/functor/integrate_ode_rk45.hpp>
 #include <stan/math/prim/functor/left_fold.hpp>
 #include <stan/math/prim/functor/map_rect.hpp>
 #include <stan/math/prim/functor/map_rect_combine.hpp>
diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
new file mode 100644
index 00000000000..f6328da618f
--- /dev/null
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -0,0 +1,151 @@
+#ifndef STAN_MATH_PRIM_FUNCTOR_COUPLED_ODE_SYSTEM_HPP
+#define STAN_MATH_PRIM_FUNCTOR_COUPLED_ODE_SYSTEM_HPP
+
+#include <stan/math/prim/fun/value_of.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/err.hpp>
+#include <stdexcept>
+#include <ostream>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+/**
+ * The <code>coupled_ode_system</code> template specialization
+ * for unknown initial values and unknown parameters.
+ *
+ * <p>This coupled ode system has N + (N +  M) * N states where N is
+ * the size of the base ode system and M is the number of parameters.
+ *
+ * <p>For the coupled ode system, the first N states are the base
+ * system's states: \f$ \frac{d x_n}{dt} \f$.
+ *
+ * <p>The next N + M states correspond to the sensitivities of the
+ * initial conditions, then to the sensitivities of the parameters
+ * with respect to the to the first base system equation:
+ *
+ * \f[
+ *   \frac{d x_{N + n}}{dt}
+ *     = \frac{d}{dt} \frac{\partial x_1}{\partial y0_n}
+ * \f]
+ *
+ * \f[
+ *   \frac{d x_{N + N + m}}{dt}
+ *     = \frac{d}{dt} \frac{\partial x_1}{\partial \theta_m}
+ * \f]
+ *
+ * <p>The next N + M states correspond to the sensitivities
+ * of the initial conditions followed by the sensitivites of the
+ * parameters with respect to the second base system equation, and
+ * so on through the last base system equation.
+ *
+ * <p>Note: Calculating the sensitivity system requires the Jacobian
+ * of the base ODE RHS wrt to the parameters theta. The parameter
+ * vector theta is constant for successive calls to the exposed
+ * operator(). For this reason, the parameter vector theta is copied
+ * upon construction onto the nochain var autodiff tape which is used
+ * in the the nested autodiff performed in the operator() of this
+ * adaptor. Doing so reduces the size of the nested autodiff and
+ * speeds up autodiff. As a side effect, the parameter vector theta
+ * will remain on the nochain autodiff part of the autodiff tape being
+ * in use even after destruction of the given instance. Moreover, the
+ * adjoint zeroing for the nested system does not cover the theta
+ * parameter vector part of the nochain autodiff tape and is therefore
+ * set to zero using a dedicated loop.
+ *
+ * @tparam F base ode system functor. Must provide
+ *   <code>operator()(double t, std::vector<var> y, std::vector<var> theta,
+ *          std::vector<double> x, std::vector<int>x_int, std::ostream*
+ * msgs)</code>
+ */
+
+template <bool Enable, typename T_initial, typename T_t0, typename T_ts, typename F, typename... Args>
+struct coupled_ode_system_impl;
+  
+template <typename T_initial, typename T_t0, typename T_ts, typename F, typename... Args>
+struct coupled_ode_system_impl<true, T_initial, T_t0, T_ts, F, Args...> {
+  const F& f_;
+  const std::vector<double>& y0_;
+  std::tuple<const Args&...> args_tuple_;
+  const size_t N_;
+  std::ostream* msgs_;
+
+  /**
+   * Construct a coupled ode system from the base system function,
+   * initial state of the base system, parameters, and a stream for
+   * messages.
+   *
+   * @param[in] f the base ODE system functor
+   * @param[in] y0 the initial state of the base ode
+   * @param[in] theta parameters of the base ode
+   * @param[in] x real data
+   * @param[in] x_int integer data
+   * @param[in, out] msgs stream for messages
+   */
+  coupled_ode_system_impl(const F& f, const std::vector<double>& y0,
+			  const Args&... args, std::ostream* msgs)
+      : f_(f),
+        y0_(y0),
+	args_tuple_(args...),
+        N_(y0.size()),
+        msgs_(msgs) {
+  }
+
+  void operator()(const std::vector<double>& y, std::vector<double>& dy_dt,
+                  double t) const {
+    dy_dt = apply([&](const Args&... args) {
+	return f_(t, y, args..., msgs_);
+      }, args_tuple_);
+
+    check_size_match("coupled_ode_system", "y", y.size(), "dy_dt",
+                     dy_dt.size());
+  }
+
+  std::vector<double> build_output(const std::vector<double>& coupled_state, const double& t) const {
+    return std::vector<double>(coupled_state.data(), coupled_state.data() + N_);
+  }
+
+  /**
+   * Returns the size of the coupled system.
+   *
+   * @return size of the coupled system.
+   */
+  size_t size() const { return N_; }
+
+  /**
+   * Returns the initial state of the coupled system.
+   *
+   * <p>Because the starting state is unknown, the coupled system
+   * incorporates the initial conditions as parameters. At the initial
+   * time the Jacobian of the integrated function is the identity
+   * matrix. In addition the coupled system includes the Jacobian of
+   * the integrated function wrt to the parameters. This Jacobian is
+   * zero at the initial time-point.
+   *
+   * @return the initial condition of the coupled system.  This is a
+   *   vector of length size() where the first N values are the
+   *   initial condition of the base ODE and the next N*N elements
+   *   correspond to the identity matrix which is the Jacobian of the
+   *   integrated function at the initial time-point. The last N*M
+   *   elements are all zero as these are the Jacobian wrt to the
+   *   parameters at the initial time-point, which is zero.
+   */
+  std::vector<double> initial_state() const {
+    return value_of(y0_);
+  }
+};
+
+template <typename T_initial, typename T_t0, typename T_ts, typename F, typename... Args>
+struct coupled_ode_system :
+    public coupled_ode_system_impl<std::is_arithmetic<return_type_t<T_initial, T_t0, T_ts, Args...>>::value,
+				   T_initial, T_t0, T_ts, F, Args...> {
+  coupled_ode_system(const F& f, const std::vector<T_initial>& y0,
+		     const Args&... args, std::ostream* msgs)
+    : coupled_ode_system_impl<std::is_arithmetic<return_type_t<T_initial, T_t0, T_ts, Args...>>::value,
+			      T_initial, T_t0, T_ts, F, Args...>(f, y0, args..., msgs) {}
+};
+
+}  // namespace math
+}  // namespace stan
+#endif
diff --git a/stan/math/rev/functor/integrate_ode_rk45.hpp b/stan/math/prim/functor/integrate_ode_rk45.hpp
similarity index 91%
rename from stan/math/rev/functor/integrate_ode_rk45.hpp
rename to stan/math/prim/functor/integrate_ode_rk45.hpp
index aac4e36693e..1212e3cc48d 100644
--- a/stan/math/rev/functor/integrate_ode_rk45.hpp
+++ b/stan/math/prim/functor/integrate_ode_rk45.hpp
@@ -1,10 +1,9 @@
-#ifndef STAN_MATH_REV_FUNCTOR_INTEGRATE_ODE_RK45_HPP
-#define STAN_MATH_REV_FUNCTOR_INTEGRATE_ODE_RK45_HPP
+#ifndef STAN_MATH_PRIM_FUNCTOR_INTEGRATE_ODE_RK45_HPP
+#define STAN_MATH_PRIM_FUNCTOR_INTEGRATE_ODE_RK45_HPP
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
-#include <stan/math/rev/functor/coupled_ode_system.hpp>
-#include <stan/math/rev/functor/coupled_ode_observer.hpp>
+#include <stan/math/prim/functor/coupled_ode_system.hpp>
 #include <stan/math/prim/fun/value_of.hpp>
 #include <stan/math/prim/functor/apply.hpp>
 #include <boost/version.hpp>
@@ -68,7 +67,7 @@ namespace math {
  * same size as the state variable, corresponding to a time in ts.
  */
 
-template <typename ...Args, typename F, typename T1, typename T_t0, typename T_ts>
+template <typename... Args, typename F, typename T1, typename T_t0, typename T_ts>
 std::vector<std::vector<return_type_t<T1, T_t0, T_ts, Args...>>> integrate_ode_rk45(
     const F& f, const std::vector<T1>& y0, const T_t0& t0,
     const std::vector<T_ts>& ts,
@@ -112,7 +111,7 @@ std::vector<std::vector<return_type_t<T1, T_t0, T_ts, Args...>>> integrate_ode_r
 
   using return_t = return_type_t<T1, T_t0, T_ts, Args...>;
   // creates basic or coupled system by template specializations
-  coupled_ode_system<T1, F, Args...> coupled_system(f, y0, args..., msgs);
+  coupled_ode_system<T1, T_t0, T_ts, F, Args...> coupled_system(f, y0, args..., msgs);
 
   // first time in the vector must be time of initial state
   std::vector<double> ts_vec(ts.size() + 1);
@@ -120,9 +119,10 @@ std::vector<std::vector<return_type_t<T1, T_t0, T_ts, Args...>>> integrate_ode_r
   std::copy(ts_dbl.begin(), ts_dbl.end(), ts_vec.begin() + 1);
 
   std::vector<std::vector<return_t>> y;
-  coupled_ode_observer<T1, T_t0, T_ts, F, Args...> observer(f, y0, t0, ts, args..., msgs, y);
+  //coupled_ode_observer<T1, T_t0, T_ts, F, Args...> observer(f, y0, t0, ts, args..., msgs, y);
   bool observer_initial_recorded = false;
-
+  size_t time_index = 0;
+  
   // avoid recording of the initial state which is included by the
   // conventions of odeint in the output
   auto filtered_observer
@@ -131,7 +131,8 @@ std::vector<std::vector<return_type_t<T1, T_t0, T_ts, Args...>>> integrate_ode_r
       observer_initial_recorded = true;
       return;
     }
-    observer(coupled_state, t);
+    y.emplace_back(coupled_system.build_output(coupled_state, ts[time_index]));
+    time_index++;
   };
 
   // the coupled system creates the coupled initial state
diff --git a/stan/math/rev/functor.hpp b/stan/math/rev/functor.hpp
index 3b2e7f8da17..3ce06abf721 100644
--- a/stan/math/rev/functor.hpp
+++ b/stan/math/rev/functor.hpp
@@ -6,17 +6,14 @@
 #include <stan/math/rev/functor/algebra_solver_powell.hpp>
 #include <stan/math/rev/functor/algebra_solver_newton.hpp>
 #include <stan/math/rev/functor/algebra_system.hpp>
-#include <stan/math/rev/functor/coupled_ode_observer.hpp>
 #include <stan/math/rev/functor/coupled_ode_system.hpp>
 #include <stan/math/rev/functor/cvodes_integrator.hpp>
-#include <stan/math/rev/functor/cvodes_ode_data.hpp>
 #include <stan/math/rev/functor/cvodes_utils.hpp>
 #include <stan/math/rev/functor/gradient.hpp>
 #include <stan/math/rev/functor/integrate_1d.hpp>
 #include <stan/math/rev/functor/integrate_dae.hpp>
 #include <stan/math/rev/functor/integrate_ode_adams.hpp>
 #include <stan/math/rev/functor/integrate_ode_bdf.hpp>
-#include <stan/math/rev/functor/integrate_ode_rk45.hpp>
 #include <stan/math/rev/functor/jacobian.hpp>
 #include <stan/math/rev/functor/kinsol_data.hpp>
 #include <stan/math/rev/functor/kinsol_solve.hpp>
diff --git a/stan/math/rev/functor/coupled_ode_observer.hpp b/stan/math/rev/functor/coupled_ode_observer.hpp
deleted file mode 100644
index 263de2b9649..00000000000
--- a/stan/math/rev/functor/coupled_ode_observer.hpp
+++ /dev/null
@@ -1,171 +0,0 @@
-#ifndef STAN_MATH_REV_FUNCTOR_COUPLED_ODE_OBSERVER_HPP
-#define STAN_MATH_REV_FUNCTOR_COUPLED_ODE_OBSERVER_HPP
-
-#include <stan/math/rev/functor/cvodes_utils.hpp>
-#include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun/sum.hpp>
-
-#include <vector>
-
-namespace stan {
-namespace math {
-
-/**
- * Observer for the coupled states.  Holds a reference to an
- * externally defined vector of vectors passed in at construction time
- * which holds the final result on the AD stack. Thus, whenever any of
- * the inputs is varying, then the output will be varying as well. The
- * sensitivities of the initials and the parameters are taken from the
- * coupled state in the order as defined by the
- * coupled_ode_system. The sensitivities at each time-point is simply
- * the ODE RHS evaluated at that time point.
- *
- * The output of this class is for all time-points in the ts vector
- * which does not contain the initial time-point by the convention
- * used in stan-math.
- *
- */
-template <typename T1, typename T_t0, typename T_ts, typename F, typename... Args>
-struct coupled_ode_observer {
-  using ReturnType = return_type_t<T1, T_t0, T_ts, Args...>;
-  
-  const F& f_;
-  const std::vector<T1>& y0_;
-  const T_t0& t0_;
-  const std::vector<T_ts>& ts_;
-  std::ostream* msgs_;
-  std::vector<std::vector<ReturnType>>& y_;
-  const std::size_t N_;
-  std::tuple<const Args&...> args_tuple_;
-  int next_ts_index_;
-
-  /**
-   * Construct a coupled ODE observer for the specified coupled
-   * vector.
-   *
-   * @tparam F type of ODE system function.
-   * @tparam T1 type of scalars for initial values.
-   * @tparam T2 type of scalars for parameters.
-   * @tparam T_t0 type of scalar of initial time point.
-   * @tparam T_ts type of time-points where ODE solution is returned.
-   * @param[in] f functor for the base ordinary differential equation.
-   * @param[in] y0 initial state.
-   * @param[in] theta parameter vector for the ODE.
-   * @param[in] t0 initial time.
-   * @param[in] ts times of the desired solutions, in strictly
-   * increasing order, all greater than the initial time.
-   * @param[in] x continuous data vector for the ODE.
-   * @param[in] x_int integer data vector for the ODE.
-   * @param[out] msgs the print stream for warning messages.
-   * @param[out] y reference to a vector of vector of the final return
-   */
-  coupled_ode_observer(const F& f,
-		       const std::vector<T1>& y0,
-		       const T_t0& t0,
-                       const std::vector<T_ts>& ts,
-		       const Args&... args,
-		       std::ostream* msgs,
-                       std::vector<std::vector<ReturnType>>& y)
-      : f_(f),
-        y0_(y0),
-        t0_(t0),
-        ts_(ts),
-        msgs_(msgs),
-        y_(y),
-	args_tuple_(args...),
-        N_(y0.size()),
-        next_ts_index_(0) {}
-
-  /**
-   * Callback function for ODE solvers to record values. The coupled
-   * state returned from the solver is added directly to the AD tree.
-   *
-   * The coupled state follows the convention as defined in the
-   * coupled_ode_system. In brief, the coupled state consists of {f,
-   * df/dy0, df/dtheta}. Here df/dy0 and df/dtheta are only present if
-   * their respective sensitivites have been requested.
-   *
-   * @param coupled_state solution at the specified time.
-   * @param t time of solution. The time must correspond to the
-   * element ts[next_ts_index_]
-   */
-  template<bool return_type_is_var = is_var<ReturnType>::value>
-  std::enable_if_t<return_type_is_var>
-  operator()(const std::vector<double>& coupled_state, double t) {
-    check_less("coupled_ode_observer", "time-state number", next_ts_index_,
-               ts_.size());
-    
-    std::vector<ReturnType> yt;
-    yt.reserve(N_);
-
-    std::vector<double> dy_dt;
-    if (stan::is_var<T_ts>::value) {
-      std::vector<double> y_dbl(coupled_state.begin(),
-                                coupled_state.begin() + N_);
-      dy_dt = apply([&](const Args&... args) {
-	  return f_(value_of(ts_[next_ts_index_]), y_dbl, value_of(args)..., msgs_);
-	}, args_tuple_);
-      check_size_match("coupled_ode_observer", "dy_dt", dy_dt.size(), "states", N_);
-    }
-
-    const size_t y0_vars = internal::count_vars(y0_);
-    const size_t args_vars = apply([&](const Args&... args) { return internal::count_vars(args...); }, args_tuple_);
-    // When true this is 1 and not ts_.size() because there's
-    //   only one time point involved with this output
-    const size_t time_vars = (stan::is_var<T_ts>::value) ? 1 : 0;
-    const size_t total_vars = y0_vars + args_vars + time_vars;
-    
-    for (size_t j = 0; j < N_; j++) {
-      vari** varis = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
-      double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(total_vars);
-
-      vari** varis_ptr = varis;
-      double* partials_ptr = partials;
-
-      size_t offset = 0;
-
-      // iterate over parameters for each equation
-      varis_ptr = internal::save_varis(varis_ptr, y0_);
-      for (std::size_t k = 0; k < y0_vars; k++) {
-	//*varis_ptr = y0[k].vi_;
-	*partials_ptr = coupled_state[N_ + y0_vars * k + j];
-	partials_ptr++;
-      }
-
-      varis_ptr = apply([&varis_ptr](const Args&... args) {
-	  return internal::save_varis(varis_ptr, args...);
-	}, args_tuple_);
-      for (std::size_t k = 0; k < args_vars; k++) {
-	// dy[j]_dtheta[k]
-	// theta[k].vi_
-	*partials_ptr = coupled_state[N_ + N_ * y0_vars + N_ * k + j];
-	partials_ptr++;
-      }
-
-      if (time_vars > 0) {
-	varis_ptr = internal::save_varis(varis_ptr, ts_[next_ts_index_]);
-	*partials_ptr = dy_dt[j];
-	partials_ptr++;
-	// dy[j]_dcurrent_t
-      }
-
-      yt.emplace_back(new precomputed_gradients_vari(coupled_state[j], total_vars, varis, partials));
-    }
-
-    y_.emplace_back(yt);
-    next_ts_index_++;
-  }
-
-  template<bool return_type_is_var = is_var<ReturnType>::value>
-  std::enable_if_t<not return_type_is_var>
-  operator()(const std::vector<double>& coupled_state, double t) {
-    y_.emplace_back(coupled_state);
-  }
-};
-
-}  // namespace math
-
-}  // namespace stan
-
-#endif
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index a5761b5b973..cceb946159c 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -2,6 +2,7 @@
 #define STAN_MATH_REV_FUNCTOR_COUPLED_ODE_SYSTEM_HPP
 
 #include <stan/math/rev/fun/value_of.hpp>
+#include <stan/math/prim/functor/coupled_ode_system.hpp>
 #include <stan/math/rev/functor/cvodes_utils.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core.hpp>
@@ -61,12 +62,12 @@ namespace math {
  *          std::vector<double> x, std::vector<int>x_int, std::ostream*
  * msgs)</code>
  */
-template <typename T1, typename F, typename... Args>
-struct coupled_ode_system {
-  using ReturnType = return_type_t<T1, Args...>;
+template <typename T_initial, typename T_t0, typename T_ts, typename F, typename... Args>
+struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
+  using T_Return = return_type_t<T_initial, T_t0, T_ts, Args...>;
 
   const F& f_;
-  const std::vector<T1>& y0_;
+  const std::vector<T_initial>& y0_;
   std::tuple<const Args&...> args_tuple_;
   const size_t y0_vars_;
   const size_t args_vars_;
@@ -85,8 +86,8 @@ struct coupled_ode_system {
    * @param[in] x_int integer data
    * @param[in, out] msgs stream for messages
    */
-  coupled_ode_system(const F& f, const std::vector<T1>& y0,
-                     const Args&... args, std::ostream* msgs)
+  coupled_ode_system_impl(const F& f, const std::vector<T_initial>& y0,
+			  const Args&... args, std::ostream* msgs)
       : f_(f),
         y0_(y0),
 	args_tuple_(args...),
@@ -110,9 +111,7 @@ struct coupled_ode_system {
    * @throw exception if the base ode function does not return the
    *    expected number of derivatives, N.
    */
-  template<bool return_type_is_var = is_var<ReturnType>::value>
-  std::enable_if_t<return_type_is_var>
-  operator()(const std::vector<double>& z, std::vector<double>& dz_dt,
+  void operator()(const std::vector<double>& z, std::vector<double>& dz_dt,
                   double t) const {
     using std::vector;
 
@@ -170,16 +169,66 @@ struct coupled_ode_system {
     recover_memory_nested();
   }
 
-  template<bool return_type_is_var = is_var<ReturnType>::value>
-  std::enable_if_t<not return_type_is_var>
-  operator()(const std::vector<double>& y, std::vector<double>& dy_dt,
-                  double t) const {
-    dy_dt = apply([&](const Args&... args) {
-	return f_(t, y, args..., msgs_);
-      }, args_tuple_);
+  template<typename T_t>
+  std::vector<var> build_output(const std::vector<double>& coupled_state, const T_t& t) const {
+    std::vector<double> y_dbl(coupled_state.data(), coupled_state.data() + N_);
+
+    std::vector<var> yt;
+    yt.reserve(N_);
+    
+    std::vector<double> dy_dt;
+    if (is_var<T_t>::value) {
+      std::vector<double> y_dbl(coupled_state.begin(),
+                                coupled_state.begin() + N_);
+      /*vector<var> dy_dt_vars = apply([&](const Args&... args) {
+	  return f_(t, y_vars, args..., msgs_);
+	  }, local_args_tuple);*/
+      dy_dt = apply([&](auto&&... args) {
+	  return f_(value_of(t), y_dbl, value_of(args)..., msgs_);
+	}, args_tuple_);
+      check_size_match("coupled_ode_observer", "dy_dt", dy_dt.size(), "states", N_);
+    }
+    
+    for (size_t j = 0; j < N_; j++) {
+      // When true this is 1 and not ts_.size() because there's
+      //   only one time point involved with this output
+      const size_t total_vars = y0_vars_ + args_vars_ + ((is_var<T_t>::value) ? 1 : 0);
+
+      vari** varis = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
+      double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(total_vars);
+
+      vari** varis_ptr = varis;
+      double* partials_ptr = partials;
+
+      // iterate over parameters for each equation
+      varis_ptr = internal::save_varis(varis_ptr, y0_);
+      for (std::size_t k = 0; k < y0_vars_; k++) {
+	//*varis_ptr = y0[k].vi_;
+	*partials_ptr = coupled_state[N_ + y0_vars_ * k + j];
+	partials_ptr++;
+      }
+
+      varis_ptr = apply([&varis_ptr](auto&&... args) {
+	  return internal::save_varis(varis_ptr, args...);
+	}, args_tuple_);
+      for (std::size_t k = 0; k < args_vars_; k++) {
+	// dy[j]_dtheta[k]
+	// theta[k].vi_
+	*partials_ptr = coupled_state[N_ + N_ * y0_vars_ + N_ * k + j];
+	partials_ptr++;
+      }
+
+      if ((stan::is_var<T_t>::value) ? 1 : 0) {
+	varis_ptr = internal::save_varis(varis_ptr, t);
+	*partials_ptr = dy_dt[j];
+	partials_ptr++;
+	// dy[j]_dcurrent_t
+      }
+
+      yt.emplace_back(new precomputed_gradients_vari(coupled_state[j], total_vars, varis, partials));
+    }
 
-    check_size_match("coupled_ode_system", "y", y.size(), "dy_dt",
-                     dy_dt.size());
+    return yt;
   }
 
   /**
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 736a018e947..3019e213139 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -4,8 +4,6 @@
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/functor/cvodes_utils.hpp>
 #include <stan/math/rev/functor/coupled_ode_system.hpp>
-#include <stan/math/rev/functor/cvodes_ode_data.hpp>
-#include <stan/math/rev/functor/coupled_ode_observer.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/value_of.hpp>
 #include <cvodes/cvodes.h>
@@ -23,10 +21,185 @@ namespace math {
  *
  * @tparam Lmm ID of ODE solver (1: ADAMS, 2: BDF)
  */
-template <int Lmm>
+template <int Lmm, typename F, typename T_initial,
+	  typename T_t0, typename T_ts, typename... T_Args>
 class cvodes_integrator {
- public:
-  cvodes_integrator() {}
+  using T_Return = return_type_t<T_initial, T_t0, T_ts, T_Args...>;
+
+  const F& f_;
+  const std::vector<T_initial>& y0_;
+  const T_t0& t0_;
+  const std::vector<T_ts>& ts_;
+  std::tuple<const T_Args&...> args_tuple_;
+  const size_t N_;
+  std::ostream* msgs_;
+  double relative_tolerance_;
+  double absolute_tolerance_;
+  long int max_num_steps_;
+
+  const size_t y0_vars_;
+  const size_t args_vars_;
+
+  const coupled_ode_system<T_initial, T_t0, T_ts, F, T_Args...> coupled_ode_;
+
+  std::vector<double> coupled_state_;
+  N_Vector nv_state_;
+  N_Vector* nv_state_sens_;
+  SUNMatrix A_;
+  SUNLinearSolver LS_;
+
+public:
+  cvodes_integrator(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
+		    const std::vector<T_ts>& ts, const T_Args&... args,
+		    std::ostream* msgs, double relative_tolerance,
+		    double absolute_tolerance,
+		    long int max_num_steps)
+    : f_(f),
+      y0_(y0),
+      t0_(t0),
+      ts_(ts),
+      args_tuple_(args...),
+      N_(y0.size()),
+      msgs_(msgs),
+      relative_tolerance_(relative_tolerance),
+      absolute_tolerance_(absolute_tolerance),
+      max_num_steps_(max_num_steps),
+      y0_vars_(internal::count_vars(y0_)),
+      args_vars_(internal::count_vars(args...)),
+      coupled_ode_(f, y0, args..., msgs),
+      coupled_state_(coupled_ode_.initial_state()) {
+    using initial_var = stan::is_var<T_initial>;
+
+    const char* fun = "cvodes_integrator::integrate";
+
+    check_finite(fun, "initial state", y0_);
+    check_finite(fun, "initial time", t0_);
+    check_finite(fun, "times", ts_);
+
+    // Code from: https://stackoverflow.com/a/17340003 . Should probably do something better
+    apply([&](auto&&... args) {
+	std::vector<int> unused_temp{ 0, (check_finite(fun, "ode parameters and data", args), 0)... };
+      }, args_tuple_);
+
+    check_nonzero_size(fun, "times", ts_);
+    check_nonzero_size(fun, "initial state", y0_);
+    check_ordered(fun, "times", ts_);
+    check_less(fun, "initial time", t0_, ts_[0]);
+    check_positive_finite(fun, "relative_tolerance", relative_tolerance_);
+    check_positive_finite(fun, "absolute_tolerance", absolute_tolerance_);
+    check_positive(fun, "max_num_steps", max_num_steps_);
+
+    nv_state_ = N_VMake_Serial(N_, &coupled_state_[0]);
+    nv_state_sens_ = nullptr;
+    A_ = SUNDenseMatrix(N_, N_);
+    LS_ = SUNDenseLinearSolver(nv_state_, A_);
+
+    if (y0_vars_ + args_vars_ > 0) {
+      nv_state_sens_ = N_VCloneVectorArrayEmpty_Serial(y0_vars_ + args_vars_, nv_state_);
+      for (std::size_t i = 0; i < y0_vars_ + args_vars_; i++) {
+        NV_DATA_S(nv_state_sens_[i]) = &coupled_state_[N_] + i * N_;
+      }
+    }
+  }
+
+  ~cvodes_integrator() {
+    SUNLinSolFree(LS_);
+    SUNMatDestroy(A_);
+    N_VDestroy_Serial(nv_state_);
+    if (y0_vars_ + args_vars_ > 0) {
+      N_VDestroyVectorArray_Serial(nv_state_sens_, y0_vars_ + args_vars_);
+    }
+  }
+
+  /**
+   * Implements the function of type CVRhsFn which is the user-defined
+   * ODE RHS passed to CVODES.
+   */
+  static int cv_rhs(realtype t, N_Vector y, N_Vector ydot, void* user_data) {
+    const cvodes_integrator* integrator = static_cast<const cvodes_integrator*>(user_data);
+    integrator->rhs(t, NV_DATA_S(y), NV_DATA_S(ydot));
+    return 0;
+  }
+
+  /**
+   * Implements the function of type CVSensRhsFn which is the
+   * RHS of the sensitivity ODE system.
+   */
+  static int cv_rhs_sens(int Ns, realtype t, N_Vector y, N_Vector ydot,
+                         N_Vector* yS, N_Vector* ySdot, void* user_data,
+                         N_Vector tmp1, N_Vector tmp2) {
+    const cvodes_integrator* integrator = static_cast<const cvodes_integrator*>(user_data);
+    integrator->rhs_sens(t, NV_DATA_S(y), yS, ySdot);
+    return 0;
+  }
+
+  /**
+   * Implements the function of type CVDlsJacFn which is the
+   * user-defined callback for CVODES to calculate the jacobian of the
+   * ode_rhs wrt to the states y. The jacobian is stored in column
+   * major format.
+   */
+  static int cv_jacobian_states(realtype t, N_Vector y, N_Vector fy,
+                                SUNMatrix J, void* user_data, N_Vector tmp1,
+                                N_Vector tmp2, N_Vector tmp3) {
+    const cvodes_integrator* integrator = static_cast<const cvodes_integrator*>(user_data);
+    integrator->jacobian_states(t, NV_DATA_S(y), J);
+    return 0;
+  }
+  /**
+   * Calculates the ODE RHS, dy_dt, using the user-supplied functor at
+   * the given time t and state y.
+   */
+  inline void rhs(double t, const double y[], double dy_dt[]) const {
+    const std::vector<double> y_vec(y, y + N_);
+    std::vector<double> dy_dt_vec = apply([&](auto&&... args) {
+	return f_(t, y_vec, value_of(args)..., msgs_);
+      }, args_tuple_);
+    check_size_match("cvodes_ode_data", "dz_dt", dy_dt_vec.size(), "states",
+                     N_);
+    std::move(dy_dt_vec.begin(), dy_dt_vec.end(), dy_dt);
+  }
+
+  /**
+   * Calculates the jacobian of the ODE RHS wrt to its states y at the
+   * given time-point t and state y.
+   * Note that the jacobian of the ODE system is the coupled ode system for
+   * varying states evaluated at the state y whenever we choose state
+   * y to be the initial of the coupled ode system.
+   */
+  inline void jacobian_states(double t, const double y[], SUNMatrix J) const {
+    start_nested();
+    const std::vector<var> y_vec_var(y, y + N_);
+    auto ode_jacobian = apply([&](auto&&... args) {
+	return coupled_ode_system<var, double, double, F, decltype(value_of(args))...>(f_, y_vec_var, value_of(args)..., msgs_);
+      }, args_tuple_);
+    std::vector<double>&& jacobian_y = std::vector<double>(ode_jacobian.size());
+    ode_jacobian(ode_jacobian.initial_state(), jacobian_y, t);
+    std::move(jacobian_y.begin() + N_, jacobian_y.end(), SM_DATA_D(J));
+    recover_memory_nested();
+  }
+
+  /**
+   * Calculates the RHS of the sensitivity ODE system which
+   * corresponds to the coupled ode system from which the first N
+   * states are omitted, since the first N states are the ODE RHS
+   * which CVODES separates from the main ODE RHS.
+   */
+  inline void rhs_sens(double t, const double y[], N_Vector* yS,
+                       N_Vector* ySdot) const {
+    std::vector<double> z(coupled_state_.size());
+    std::vector<double>&& dz_dt = std::vector<double>(coupled_state_.size());
+    std::copy(y, y + N_, z.begin());
+    for (std::size_t s = 0; s < y0_vars_ + args_vars_; s++) {
+      std::copy(NV_DATA_S(yS[s]), NV_DATA_S(yS[s]) + N_,
+                z.begin() + (s + 1) * N_);
+    }
+    coupled_ode_(z, dz_dt, t);
+    for (std::size_t s = 0; s < y0_vars_ + args_vars_; s++) {
+      std::move(dz_dt.begin() + (s + 1) * N_, dz_dt.begin() + (s + 2) * N_,
+                NV_DATA_S(ySdot[s]));
+    }
+  }
 
   /**
    * Return the solutions for the specified system of ordinary
@@ -68,122 +241,74 @@ class cvodes_integrator {
    * @return a vector of states, each state being a vector of the
    * same size as the state variable, corresponding to a time in ts.
    */
-  template <typename... Args, typename F, typename T_initial,
-	    typename T_t0, typename T_ts>
-  std::vector<std::vector<
-		typename stan::return_type<T_initial, T_t0, T_ts, Args...>::type>>
-  integrate(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
-            const std::vector<T_ts>& ts, const Args&... args,
-            std::ostream* msgs, double relative_tolerance,
-            double absolute_tolerance,
-            long int max_num_steps) {  // NOLINT(runtime/int)
-    using initial_var = stan::is_var<T_initial>;
+  std::vector<std::vector<T_Return>> integrate() {  // NOLINT(runtime/int)
+    std::vector<std::vector<T_Return>> y;
 
-    const char* fun = "integrate_ode_cvodes";
-
-    const double t0_dbl = value_of(t0);
-    const std::vector<double> ts_dbl = value_of(ts);
-
-    check_finite(fun, "initial state", y0);
-    check_finite(fun, "initial time", t0_dbl);
-    check_finite(fun, "times", ts_dbl);
-
-    // Code from: https://stackoverflow.com/a/17340003 . Should probably do something better
-    std::vector<int> unused_temp{ 0, (check_finite(fun, "ode parameters and data", args), 0)... };
-
-    check_nonzero_size(fun, "times", ts);
-    check_nonzero_size(fun, "initial state", y0);
-    check_ordered(fun, "times", ts_dbl);
-    check_less(fun, "initial time", t0_dbl, ts_dbl[0]);
-    if (relative_tolerance <= 0) {
-      invalid_argument("integrate_ode_cvodes", "relative_tolerance,",
-                       relative_tolerance, "", ", must be greater than 0");
-    }
-    if (absolute_tolerance <= 0) {
-      invalid_argument("integrate_ode_cvodes", "absolute_tolerance,",
-                       absolute_tolerance, "", ", must be greater than 0");
-    }
-    if (max_num_steps <= 0) {
-      invalid_argument("integrate_ode_cvodes", "max_num_steps,", max_num_steps,
-                       "", ", must be greater than 0");
-    }
-
-
-    const size_t y0_vars = internal::count_vars(y0);
-    const size_t args_vars = internal::count_vars(args...);
-    const size_t S = y0_vars + args_vars;
-
-    using ode_data = cvodes_ode_data<F, T_initial, Args...>;
-    ode_data cvodes_data(f, y0, args..., msgs);
+    const double t0_dbl = value_of(t0_);
+    const std::vector<double> ts_dbl = value_of(ts_);
 
     void* cvodes_mem = CVodeCreate(Lmm);
     if (cvodes_mem == nullptr) {
       throw std::runtime_error("CVodeCreate failed to allocate memory");
     }
 
-    const size_t coupled_size = cvodes_data.coupled_ode_.size();
-
-    using return_t = return_type_t<T_initial, T_t0, T_ts, Args...>;
-    
-    std::vector<std::vector<return_t>> y;
-    coupled_ode_observer<T_initial, T_t0, T_ts, F, Args...> observer(f, y0, t0, ts, args..., msgs, y);
-
     try {
-      check_flag_sundials(CVodeInit(cvodes_mem, &ode_data::cv_rhs, t0_dbl,
-                                    cvodes_data.nv_state_),
+      check_flag_sundials(CVodeInit(cvodes_mem, &cvodes_integrator::cv_rhs, t0_dbl,
+                                    nv_state_),
                           "CVodeInit");
 
       // Assign pointer to this as user data
-      check_flag_sundials(
-          CVodeSetUserData(cvodes_mem, reinterpret_cast<void*>(&cvodes_data)),
-          "CVodeSetUserData");
+      check_flag_sundials(CVodeSetUserData(cvodes_mem, reinterpret_cast<void*>(this)),
+			  "CVodeSetUserData");
 
-      cvodes_set_options(cvodes_mem, relative_tolerance, absolute_tolerance,
-                         max_num_steps);
+      cvodes_set_options(cvodes_mem, relative_tolerance_, absolute_tolerance_,
+                         max_num_steps_);
 
       // for the stiff solvers we need to reserve additional memory
       // and provide a Jacobian function call. new API since 3.0.0:
       // create matrix object and linear solver object; resource
       // (de-)allocation is handled in the cvodes_ode_data
-      check_flag_sundials(
-          CVodeSetLinearSolver(cvodes_mem, cvodes_data.LS_, cvodes_data.A_),
-          "CVodeSetLinearSolver");
-      check_flag_sundials(
-          CVodeSetJacFn(cvodes_mem, &ode_data::cv_jacobian_states),
-          "CVodeSetJacFn");
+      check_flag_sundials(CVodeSetLinearSolver(cvodes_mem, LS_, A_),
+			  "CVodeSetLinearSolver");
+      check_flag_sundials(CVodeSetJacFn(cvodes_mem, &cvodes_integrator::cv_jacobian_states),
+			  "CVodeSetJacFn");
 
       // initialize forward sensitivity system of CVODES as needed
-      if (S > 0) {
-        check_flag_sundials(
-            CVodeSensInit(cvodes_mem, static_cast<int>(S), CV_STAGGERED,
-                          &ode_data::cv_rhs_sens, cvodes_data.nv_state_sens_),
-            "CVodeSensInit");
+      if (y0_vars_ + args_vars_ > 0) {
+        check_flag_sundials(CVodeSensInit(cvodes_mem, static_cast<int>(y0_vars_ + args_vars_), CV_STAGGERED,
+					  &cvodes_integrator::cv_rhs_sens, nv_state_sens_),
+			    "CVodeSensInit");
 
         check_flag_sundials(CVodeSensEEtolerances(cvodes_mem),
                             "CVodeSensEEtolerances");
       }
 
       double t_init = t0_dbl;
-      for (size_t n = 0; n < ts.size(); ++n) {
+      for (size_t n = 0; n < ts_.size(); ++n) {
         double t_final = ts_dbl[n];
+	
         if (t_final != t_init) {
-          check_flag_sundials(CVode(cvodes_mem, t_final, cvodes_data.nv_state_,
+          check_flag_sundials(CVode(cvodes_mem, t_final, nv_state_,
                                     &t_init, CV_NORMAL),
                               "CVode");
         }
-        if (S > 0) {
+	
+        if (y0_vars_ + args_vars_ > 0) {
           check_flag_sundials(
-              CVodeGetSens(cvodes_mem, &t_init, cvodes_data.nv_state_sens_),
+              CVodeGetSens(cvodes_mem, &t_init, nv_state_sens_),
               "CVodeGetSens");
         }
-        observer(cvodes_data.coupled_state_, t_final);
-        t_init = t_final;
+
+        //observer(cvodes_data.coupled_state_, t_final);
+	y.emplace_back(coupled_ode_.build_output(coupled_state_, ts_[n]));
+
+	t_init = t_final;
       }
     } catch (const std::exception& e) {
       CVodeFree(&cvodes_mem);
       throw;
     }
-
+      
     CVodeFree(&cvodes_mem);
 
     return y;
diff --git a/stan/math/rev/functor/cvodes_ode_data.hpp b/stan/math/rev/functor/cvodes_ode_data.hpp
deleted file mode 100644
index aa7d823315c..00000000000
--- a/stan/math/rev/functor/cvodes_ode_data.hpp
+++ /dev/null
@@ -1,196 +0,0 @@
-#ifndef STAN_MATH_REV_FUNCTOR_CVODES_ODE_DATA_HPP
-#define STAN_MATH_REV_FUNCTOR_CVODES_ODE_DATA_HPP
-
-#include <stan/math/rev/meta.hpp>
-#include <stan/math/rev/functor/coupled_ode_system.hpp>
-#include <cvodes/cvodes.h>
-#include <sunmatrix/sunmatrix_dense.h>
-#include <sunlinsol/sunlinsol_dense.h>
-#include <nvector/nvector_serial.h>
-#include <algorithm>
-#include <vector>
-
-namespace stan {
-namespace math {
-
-/**
- * CVODES ode data holder object which is used during CVODES
- * integration for CVODES callbacks.
- *
- * @tparam F type of functor for the base ode system.
- * @tparam T_initial type of initial values
- * @tparam T_param type of parameters
- */
-template <typename F, typename T_initial, typename... Args>
-class cvodes_ode_data {
-  const F& f_;
-  const std::vector<T_initial>& y0_;
-  std::tuple<const Args&...> args_tuple_;
-  const size_t N_;
-  std::ostream* msgs_;
-  const size_t y0_vars_;
-  const size_t args_vars_;
-  const size_t S_;
-
-  using ode_data = cvodes_ode_data<F, T_initial, Args...>;
- public:
-  const coupled_ode_system<T_initial, F, Args...> coupled_ode_;
-  std::vector<double> coupled_state_;
-  N_Vector nv_state_;
-  N_Vector* nv_state_sens_;
-  SUNMatrix A_;
-  SUNLinearSolver LS_;
-
-  /**
-   * Construct CVODES ode data object to enable callbacks from
-   * CVODES during ODE integration. Static callbacks are defined
-   * for the ODE RHS (<code>cv_rhs</code>), the ODE sensitivity
-   * RHS (<code>cv_rhs_sens</code>) and for the ODE Jacobian wrt
-   * to the states (<code>cv_jacobian_states</code>).
-   *
-   * The callbacks required by CVODES are detailled in
-   * https://computation.llnl.gov/sites/default/files/public/cvs_guide.pdf
-   *
-   * Note: The supplied callbacks do always return 0 which flags to
-   * CVODES that the function was successfully evaluated. Errors are
-   * handled within Stan using exceptions such that any thrown error
-   * leads to the termination of the ODE integration.
-   *
-   * @param[in] f ode functor.
-   * @param[in] y0 initial state of the base ode.
-   * @param[in] theta parameters of the base ode.
-   * @param[in] x continuous data vector for the ODE.
-   * @param[in] x_int integer data vector for the ODE.
-   * @param[in] msgs stream to which messages are printed.
-   */
-  cvodes_ode_data(const F& f,
-		  const std::vector<T_initial>& y0,
-		  const Args&... args,
-                  std::ostream* msgs)
-      : f_(f),
-        y0_(y0),
-	args_tuple_(args...),
-        N_(y0.size()),
-        msgs_(msgs),
-	y0_vars_(internal::count_vars(y0_)),
-	args_vars_(internal::count_vars(args...)),
-	S_(y0_vars_ + args_vars_),
-        coupled_ode_(f, y0, args..., msgs),
-        coupled_state_(coupled_ode_.initial_state()),
-        nv_state_(N_VMake_Serial(N_, &coupled_state_[0])),
-        nv_state_sens_(nullptr),
-        A_(SUNDenseMatrix(N_, N_)),
-        LS_(SUNDenseLinearSolver(nv_state_, A_)) {
-    if (S_ > 0) {
-      nv_state_sens_ = N_VCloneVectorArrayEmpty_Serial(S_, nv_state_);
-      for (std::size_t i = 0; i < S_; i++) {
-        NV_DATA_S(nv_state_sens_[i]) = &coupled_state_[N_] + i * N_;
-      }
-    }
-  }
-
-  ~cvodes_ode_data() {
-    SUNLinSolFree(LS_);
-    SUNMatDestroy(A_);
-    N_VDestroy_Serial(nv_state_);
-    if (S_ > 0) {
-      N_VDestroyVectorArray_Serial(nv_state_sens_, S_);
-    }
-  }
-
-  /**
-   * Implements the function of type CVRhsFn which is the user-defined
-   * ODE RHS passed to CVODES.
-   */
-  static int cv_rhs(realtype t, N_Vector y, N_Vector ydot, void* user_data) {
-    const ode_data* explicit_ode = static_cast<const ode_data*>(user_data);
-    explicit_ode->rhs(t, NV_DATA_S(y), NV_DATA_S(ydot));
-    return 0;
-  }
-
-  /**
-   * Implements the function of type CVSensRhsFn which is the
-   * RHS of the sensitivity ODE system.
-   */
-  static int cv_rhs_sens(int Ns, realtype t, N_Vector y, N_Vector ydot,
-                         N_Vector* yS, N_Vector* ySdot, void* user_data,
-                         N_Vector tmp1, N_Vector tmp2) {
-    const ode_data* explicit_ode = static_cast<const ode_data*>(user_data);
-    explicit_ode->rhs_sens(t, NV_DATA_S(y), yS, ySdot);
-    return 0;
-  }
-
-  /**
-   * Implements the function of type CVDlsJacFn which is the
-   * user-defined callback for CVODES to calculate the jacobian of the
-   * ode_rhs wrt to the states y. The jacobian is stored in column
-   * major format.
-   */
-  static int cv_jacobian_states(realtype t, N_Vector y, N_Vector fy,
-                                SUNMatrix J, void* user_data, N_Vector tmp1,
-                                N_Vector tmp2, N_Vector tmp3) {
-    const ode_data* explicit_ode = static_cast<const ode_data*>(user_data);
-    return explicit_ode->jacobian_states(t, NV_DATA_S(y), J);
-  }
-
- private:
-  /**
-   * Calculates the ODE RHS, dy_dt, using the user-supplied functor at
-   * the given time t and state y.
-   */
-  inline void rhs(double t, const double y[], double dy_dt[]) const {
-    const std::vector<double> y_vec(y, y + N_);
-    std::vector<double> dy_dt_vec = apply([&](const Args&... args) {
-	return f_(t, y_vec, value_of(args)..., msgs_);
-      }, args_tuple_);
-    check_size_match("cvodes_ode_data", "dz_dt", dy_dt_vec.size(), "states",
-                     N_);
-    std::move(dy_dt_vec.begin(), dy_dt_vec.end(), dy_dt);
-  }
-
-  /**
-   * Calculates the jacobian of the ODE RHS wrt to its states y at the
-   * given time-point t and state y.
-   * Note that the jacobian of the ODE system is the coupled ode system for
-   * varying states evaluated at the state y whenever we choose state
-   * y to be the initial of the coupled ode system.
-   */
-  inline int jacobian_states(double t, const double y[], SUNMatrix J) const {
-    start_nested();
-    const std::vector<var> y_vec_var(y, y + N_);
-    auto ode_jacobian = apply([&](const Args&... args) {
-	return coupled_ode_system<var, F, decltype(value_of(args))...>(f_, y_vec_var, value_of(args)..., msgs_);
-      }, args_tuple_);
-    std::vector<double>&& jacobian_y = std::vector<double>(ode_jacobian.size());
-    ode_jacobian(ode_jacobian.initial_state(), jacobian_y, t);
-    std::move(jacobian_y.begin() + N_, jacobian_y.end(), SM_DATA_D(J));
-    recover_memory_nested();
-    return 0;
-  }
-
-  /**
-   * Calculates the RHS of the sensitivity ODE system which
-   * corresponds to the coupled ode system from which the first N
-   * states are omitted, since the first N states are the ODE RHS
-   * which CVODES separates from the main ODE RHS.
-   */
-  inline void rhs_sens(double t, const double y[], N_Vector* yS,
-                       N_Vector* ySdot) const {
-    std::vector<double> z(coupled_state_.size());
-    std::vector<double>&& dz_dt = std::vector<double>(coupled_state_.size());
-    std::copy(y, y + N_, z.begin());
-    for (std::size_t s = 0; s < S_; s++) {
-      std::copy(NV_DATA_S(yS[s]), NV_DATA_S(yS[s]) + N_,
-                z.begin() + (s + 1) * N_);
-    }
-    coupled_ode_(z, dz_dt, t);
-    for (std::size_t s = 0; s < S_; s++) {
-      std::move(dz_dt.begin() + (s + 1) * N_, dz_dt.begin() + (s + 2) * N_,
-                NV_DATA_S(ySdot[s]));
-    }
-  }
-};
-
-}  // namespace math
-}  // namespace stan
-#endif
diff --git a/stan/math/rev/functor/integrate_ode_adams.hpp b/stan/math/rev/functor/integrate_ode_adams.hpp
index 40690f51fcb..a7bb8034010 100644
--- a/stan/math/rev/functor/integrate_ode_adams.hpp
+++ b/stan/math/rev/functor/integrate_ode_adams.hpp
@@ -21,10 +21,13 @@ integrate_ode_adams(const F& f, const std::vector<T_initial>& y0,
                     double relative_tolerance = 1e-10,
                     double absolute_tolerance = 1e-10,
                     long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
-  stan::math::cvodes_integrator<CV_ADAMS> integrator;
-  return integrator.integrate(f, y0, t0, ts, theta, x, x_int, msgs,
-                              relative_tolerance, absolute_tolerance,
-                              max_num_steps);
+  stan::math::cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts,
+				std::vector<T_param>,
+				std::vector<double>,
+				std::vector<int>> integrator(f, y0, t0, ts, theta, x, x_int, msgs,
+							     relative_tolerance, absolute_tolerance,
+							     max_num_steps);
+  return integrator.integrate();
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/integrate_ode_bdf.hpp b/stan/math/rev/functor/integrate_ode_bdf.hpp
index f6052fbc6a0..760dc222093 100644
--- a/stan/math/rev/functor/integrate_ode_bdf.hpp
+++ b/stan/math/rev/functor/integrate_ode_bdf.hpp
@@ -21,12 +21,13 @@ integrate_ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
                   double relative_tolerance = 1e-10,
                   double absolute_tolerance = 1e-10,
                   long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
-  stan::math::cvodes_integrator<CV_BDF> integrator;
-  return integrator.integrate<std::vector<T_param>,
-			      std::vector<double>,
-			      std::vector<int>>(f, y0, t0, ts, theta, x, x_int, msgs,
-                              relative_tolerance, absolute_tolerance,
-                              max_num_steps);
+  stan::math::cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts,
+				std::vector<T_param>,
+				std::vector<double>,
+				std::vector<int>> integrator(f, y0, t0, ts, theta, x, x_int, msgs,
+							     relative_tolerance, absolute_tolerance,
+							     max_num_steps);
+  return integrator.integrate();
 }
 
 }  // namespace math
diff --git a/test/unit/math/rev/functor/integrate_ode_rk45_prim_test.cpp b/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
similarity index 99%
rename from test/unit/math/rev/functor/integrate_ode_rk45_prim_test.cpp
rename to test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
index a72d02a356a..ad2d627a81b 100644
--- a/test/unit/math/rev/functor/integrate_ode_rk45_prim_test.cpp
+++ b/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
@@ -1,4 +1,4 @@
-#include <stan/math/rev.hpp>
+#include <stan/math/prim.hpp>
 #include <gtest/gtest.h>
 #include <boost/numeric/odeint.hpp>
 #include <test/unit/math/prim/functor/harmonic_oscillator.hpp>
diff --git a/test/unit/math/rev/functor/integrate_ode_adams_prim_test.cpp b/test/unit/math/rev/functor/integrate_ode_adams_prim_test.cpp
index 864eb2c799d..f9babf56361 100644
--- a/test/unit/math/rev/functor/integrate_ode_adams_prim_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_adams_prim_test.cpp
@@ -139,15 +139,15 @@ TEST(StanMathOde_integrate_ode_adams, error_conditions) {
 
   EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta, x, x_int, 0,
                                        -1, 1e-6, 10),
-                   std::invalid_argument, "relative_tolerance");
+                   std::domain_error, "relative_tolerance");
 
   EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta, x, x_int, 0,
                                        1e-6, -1, 10),
-                   std::invalid_argument, "absolute_tolerance");
+                   std::domain_error, "absolute_tolerance");
 
   EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta, x, x_int, 0,
                                        1e-6, 1e-6, -1),
-                   std::invalid_argument, "max_num_steps");
+                   std::domain_error, "max_num_steps");
 }
 
 TEST(StanMathOde_integrate_ode_adams, error_conditions_nan) {
@@ -207,7 +207,7 @@ TEST(StanMathOde_integrate_ode_adams, error_conditions_nan) {
   theta_bad[0] = nan;
   EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta_bad, x,
                                        x_int, 0, 1e-8, 1e-10, 1e6),
-                   std::domain_error, "parameter vector");
+                   std::domain_error, "ode parameters and data");
   EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta_bad, x,
                                        x_int, 0, 1e-8, 1e-10, 1e6),
                    std::domain_error, expected_is_nan.str());
@@ -217,7 +217,7 @@ TEST(StanMathOde_integrate_ode_adams, error_conditions_nan) {
     x_bad[0] = nan;
     EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta, x_bad,
                                          x_int, 0, 1e-8, 1e-10, 1e6),
-                     std::domain_error, "continuous data");
+                     std::domain_error, "ode parameters and data");
     EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta, x_bad,
                                          x_int, 0, 1e-8, 1e-10, 1e6),
                      std::domain_error, expected_is_nan.str());
@@ -304,14 +304,14 @@ TEST(StanMathOde_integrate_ode_adams, error_conditions_inf) {
   theta_bad[0] = inf;
   EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta_bad, x,
                                        x_int, 0, 1e-8, 1e-10, 1e6),
-                   std::domain_error, "parameter vector");
+                   std::domain_error, "ode parameters and data");
   EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta_bad, x,
                                        x_int, 0, 1e-8, 1e-10, 1e6),
                    std::domain_error, expected_is_inf.str());
   theta_bad[0] = -inf;
   EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta_bad, x,
                                        x_int, 0, 1e-8, 1e-10, 1e6),
-                   std::domain_error, "parameter vector");
+                   std::domain_error, "ode parameters and data");
   EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta_bad, x,
                                        x_int, 0, 1e-8, 1e-10, 1e6),
                    std::domain_error, expected_is_neg_inf.str());
@@ -321,14 +321,14 @@ TEST(StanMathOde_integrate_ode_adams, error_conditions_inf) {
     x_bad[0] = inf;
     EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta, x_bad,
                                          x_int, 0, 1e-8, 1e-10, 1e6),
-                     std::domain_error, "continuous data");
+                     std::domain_error, "ode parameters and data");
     EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta, x_bad,
                                          x_int, 0, 1e-8, 1e-10, 1e6),
                      std::domain_error, expected_is_inf.str());
     x_bad[0] = -inf;
     EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta, x_bad,
                                          x_int, 0, 1e-8, 1e-10, 1e6),
-                     std::domain_error, "continuous data");
+                     std::domain_error, "ode parameters and data");
     EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta, x_bad,
                                          x_int, 0, 1e-8, 1e-10, 1e6),
                      std::domain_error, expected_is_neg_inf.str());
diff --git a/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp
index 137827effbf..0d10674876d 100644
--- a/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp
@@ -138,15 +138,15 @@ TEST(StanMathOde_integrate_ode_bdf, error_conditions) {
 
   EXPECT_THROW_MSG(
       integrate_ode_bdf(harm_osc, y0, t0, ts, theta, x, x_int, 0, -1, 1e-6, 10),
-      std::invalid_argument, "relative_tolerance");
+      std::domain_error, "relative_tolerance");
 
   EXPECT_THROW_MSG(
       integrate_ode_bdf(harm_osc, y0, t0, ts, theta, x, x_int, 0, 1e-6, -1, 10),
-      std::invalid_argument, "absolute_tolerance");
+      std::domain_error, "absolute_tolerance");
 
   EXPECT_THROW_MSG(integrate_ode_bdf(harm_osc, y0, t0, ts, theta, x, x_int, 0,
                                      1e-6, 1e-6, -1),
-                   std::invalid_argument, "max_num_steps");
+                   std::domain_error, "max_num_steps");
 }
 
 TEST(StanMathOde_integrate_ode_bdf, error_conditions_nan) {
diff --git a/test/unit/math/rev/functor/util_cvodes_adams.hpp b/test/unit/math/rev/functor/util_cvodes_adams.hpp
index edb79e21a3e..e772330ced8 100644
--- a/test/unit/math/rev/functor/util_cvodes_adams.hpp
+++ b/test/unit/math/rev/functor/util_cvodes_adams.hpp
@@ -357,7 +357,7 @@ void test_ode_error_conditions_nan(F& f, const double& t0,
   theta_bad[0] = nan;
   EXPECT_THROW_MSG(integrate_ode_adams(f, y0, t0, ts, theta_bad, x, x_int,
                                        &msgs, 1e-8, 1e-10, 1e6),
-                   std::domain_error, "parameter vector");
+                   std::domain_error, "ode parameters and data");
   EXPECT_THROW_MSG(integrate_ode_adams(f, y0, t0, ts, theta_bad, x, x_int,
                                        &msgs, 1e-8, 1e-10, 1e6),
                    std::domain_error, expected_is_nan.str());
@@ -369,7 +369,7 @@ void test_ode_error_conditions_nan(F& f, const double& t0,
     x_bad[0] = nan;
     EXPECT_THROW_MSG(integrate_ode_adams(f, y0, t0, ts, theta, x_bad, x_int,
                                          &msgs, 1e-8, 1e-10, 1e6),
-                     std::domain_error, "continuous data");
+                     std::domain_error, "ode parameters and data");
     EXPECT_THROW_MSG(integrate_ode_adams(f, y0, t0, ts, theta, x_bad, x_int,
                                          &msgs, 1e-8, 1e-10, 1e6),
                      std::domain_error, expected_is_nan.str());
@@ -453,12 +453,12 @@ void test_ode_error_conditions_inf(F& f, const double& t0,
   std::vector<T2> theta_bad = theta;
   theta_bad[0] = inf;
   EXPECT_THROW_MSG(integrate_ode_adams(f, y0, t0, ts, theta_bad, x, x_int),
-                   std::domain_error, "parameter vector");
+                   std::domain_error, "ode parameters and data");
   EXPECT_THROW_MSG(integrate_ode_adams(f, y0, t0, ts, theta_bad, x, x_int),
                    std::domain_error, expected_is_inf.str());
   theta_bad[0] = -inf;
   EXPECT_THROW_MSG(integrate_ode_adams(f, y0, t0, ts, theta_bad, x, x_int),
-                   std::domain_error, "parameter vector");
+                   std::domain_error, "ode parameters and data");
   EXPECT_THROW_MSG(integrate_ode_adams(f, y0, t0, ts, theta_bad, x, x_int),
                    std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
@@ -468,12 +468,12 @@ void test_ode_error_conditions_inf(F& f, const double& t0,
     std::vector<double> x_bad = x;
     x_bad[0] = inf;
     EXPECT_THROW_MSG(integrate_ode_adams(f, y0, t0, ts, theta, x_bad, x_int),
-                     std::domain_error, "continuous data");
+                     std::domain_error, "ode parameters and data");
     EXPECT_THROW_MSG(integrate_ode_adams(f, y0, t0, ts, theta, x_bad, x_int),
                      std::domain_error, expected_is_inf.str());
     x_bad[0] = -inf;
     EXPECT_THROW_MSG(integrate_ode_adams(f, y0, t0, ts, theta, x_bad, x_int),
-                     std::domain_error, "continuous data");
+                     std::domain_error, "ode parameters and data");
     EXPECT_THROW_MSG(integrate_ode_adams(f, y0, t0, ts, theta, x_bad, x_int),
                      std::domain_error, expected_is_neg_inf.str());
     EXPECT_EQ("", msgs.str());

From 144bb9c8ae8525b65d2583a22209d0cb31848dcf Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Thu, 13 Feb 2020 18:18:02 -0500
Subject: [PATCH 082/189] Changed how arg_adjoints_ is allocated in reduce_sum
 and added out of bounds index tests

---
 stan/math/rev/functor/reduce_sum.hpp            | 14 +++++++++++---
 test/unit/math/prim/functor/reduce_sum_test.cpp |  6 +++---
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 11d03ff0b7e..05e729a9350 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -128,7 +128,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
           msgs_(msgs),
           args_tuple_(args...),
           sum_(0.0),
-          args_adjoints_(Eigen::VectorXd::Zero(num_shared_terms_)) {}
+          args_adjoints_(0) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
         : num_shared_terms_(other.num_shared_terms_),
@@ -137,12 +137,16 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
           msgs_(other.msgs_),
           args_tuple_(other.args_tuple_),
           sum_(0.0),
-          args_adjoints_(Eigen::VectorXd::Zero(num_shared_terms_)) {}
+          args_adjoints_(0) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty())
         return;
 
+      if(args_adjoints_.size() == 0) {
+	args_adjoints_ = Eigen::VectorXd::Zero(num_shared_terms_);
+      }
+
       try {
         start_nested();
 
@@ -189,7 +193,11 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
 
     void join(const recursive_reducer& rhs) {
       sum_ += rhs.sum_;
-      args_adjoints_ += rhs.args_adjoints_;
+      if(args_adjoints_.size() != 0 && rhs.args_adjoints_.size() != 0) {
+	args_adjoints_ += rhs.args_adjoints_;
+      } else if(args_adjoints_.size() == 0 && rhs.args_adjoints_.size() != 0) {
+	args_adjoints_ = rhs.args_adjoints_;
+      }
     }
   };
 
diff --git a/test/unit/math/prim/functor/reduce_sum_test.cpp b/test/unit/math/prim/functor/reduce_sum_test.cpp
index ddc0f43c83d..3c62280fa34 100644
--- a/test/unit/math/prim/functor/reduce_sum_test.cpp
+++ b/test/unit/math/prim/functor/reduce_sum_test.cpp
@@ -127,9 +127,9 @@ struct start_end_lpdf {
                          const std::vector<int>&, std::ostream* msgs,
                          const std::vector<int>& data) const {
     int sum = 0;
-    EXPECT_GE(start, 1);
-    EXPECT_LE(end, data.size());
-    for (size_t i = start - 1; i < end; i++) {
+    EXPECT_GE(start, 0);
+    EXPECT_LE(end, data.size() - 1);
+    for (size_t i = start; i <= end; i++) {
       sum += data[i];
     }
     return sum;

From 80ae1bfddbcb96d7d1f55a4c5f0cedb7b10f932d Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Thu, 13 Feb 2020 23:22:55 +0000
Subject: [PATCH 083/189] [Jenkins] auto-formatting by clang-format version
 5.0.0-3~16.04.1 (tags/RELEASE_500/final)

---
 stan/math/rev/functor/reduce_sum.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 05e729a9350..e0edd860b29 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -143,8 +143,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
       if (r.empty())
         return;
 
-      if(args_adjoints_.size() == 0) {
-	args_adjoints_ = Eigen::VectorXd::Zero(num_shared_terms_);
+      if (args_adjoints_.size() == 0) {
+        args_adjoints_ = Eigen::VectorXd::Zero(num_shared_terms_);
       }
 
       try {
@@ -193,10 +193,10 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
 
     void join(const recursive_reducer& rhs) {
       sum_ += rhs.sum_;
-      if(args_adjoints_.size() != 0 && rhs.args_adjoints_.size() != 0) {
-	args_adjoints_ += rhs.args_adjoints_;
-      } else if(args_adjoints_.size() == 0 && rhs.args_adjoints_.size() != 0) {
-	args_adjoints_ = rhs.args_adjoints_;
+      if (args_adjoints_.size() != 0 && rhs.args_adjoints_.size() != 0) {
+        args_adjoints_ += rhs.args_adjoints_;
+      } else if (args_adjoints_.size() == 0 && rhs.args_adjoints_.size() != 0) {
+        args_adjoints_ = rhs.args_adjoints_;
       }
     }
   };

From 7a1a27b589debf44d42e6144bb614d0a97bd286b Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 24 Feb 2020 14:42:49 -0500
Subject: [PATCH 084/189] Made deep copy in reduce_sum a little more efficient

---
 stan/math/rev/functor/reduce_sum.hpp          | 21 +++++++++----------
 .../unit/math/rev/functor/reduce_sum_test.cpp |  3 ++-
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 05e729a9350..57ff3bdbc71 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -23,15 +23,15 @@ template <typename ReduceFunction, typename ReturnType, typename Vec,
 struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
                        Vec, Args...> {
   template <typename T, require_arithmetic_t<scalar_type_t<T>>...>
-  static const T& deep_copy(const T& arg) {
+  static inline const T& deep_copy(const T& arg) {
     return arg;
   }
 
-  static var deep_copy(const var& arg) {
+  static inline var deep_copy(const var& arg) {
     return var(new vari(arg.val(), false));
   }
 
-  static std::vector<var> deep_copy(const std::vector<var>& arg) {
+  static inline std::vector<var> deep_copy(const std::vector<var>& arg) {
     std::vector<var> copy(arg.size());
     for (size_t i = 0; i < arg.size(); ++i) {
       copy[i] = new vari(arg[i].val(), false);
@@ -40,7 +40,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   template <typename T, require_t<is_var<scalar_type_t<T>>>...>
-  static std::vector<T> deep_copy(const std::vector<T>& arg) {
+  static inline std::vector<T> deep_copy(const std::vector<T>& arg) {
     std::vector<T> copy(arg.size());
     for (size_t i = 0; i < arg.size(); ++i) {
       copy[i] = deep_copy(arg[i]);
@@ -49,7 +49,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   template <int RowType, int ColType>
-  static Eigen::Matrix<var, RowType, ColType> deep_copy(
+  static inline Eigen::Matrix<var, RowType, ColType> deep_copy(
       const Eigen::Matrix<var, RowType, ColType>& arg) {
     Eigen::Matrix<var, RowType, ColType> copy(arg.rows(), arg.cols());
     for (size_t i = 0; i < arg.size(); ++i) {
@@ -152,12 +152,11 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
 
         // create a deep copy of all var's so that these are not
         // linked to any outer AD tree
-        Vec local_sub_slice(r.size());
-        int ii = 0;
+        Vec local_sub_slice;
+	local_sub_slice.reserve(r.size());
         for (int i = r.begin(); i < r.end(); ++i) {
-          local_sub_slice[ii] = deep_copy(vmapped_[i]);
-          ii++;
-        }
+          local_sub_slice.emplace_back(deep_copy(vmapped_[i]));
+	}
 
         auto args_tuple_local_copy = apply(
             [&](auto&&... args) {
@@ -178,7 +177,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
         sum_ += sub_sum_v.val();
 
         accumulate_adjoints(sliced_partials_ + r.begin(), local_sub_slice);
-
+	
         apply(
             [&](auto&&... args) {
               return accumulate_adjoints(args_adjoints_.data(), args...);
diff --git a/test/unit/math/rev/functor/reduce_sum_test.cpp b/test/unit/math/rev/functor/reduce_sum_test.cpp
index 9054d61c3ef..f7f43922801 100644
--- a/test/unit/math/rev/functor/reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/reduce_sum_test.cpp
@@ -65,6 +65,7 @@ TEST(v3_reduce_sum, gradient) {
   typedef boost::counting_iterator<std::size_t> count_iter;
   using stan::math::var;
 
+
   var lambda_v = lambda_d;
 
   std::vector<int> idata;
@@ -256,7 +257,7 @@ TEST(v3_reduce_sum, grouped_gradient_eigen) {
   const std::size_t elems = groups * elems_per_group;
   const std::size_t num_iter = 1000;
 
-  Eigen::Matrix<int, -1, 1> data(elems);
+  std::vector<int> data(elems);
   std::vector<int> gidx(elems);
 
   for (std::size_t i = 0; i != elems; ++i) {

From 66ba57378fa98fe4e59f90ae3e423599b9b14209 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 24 Feb 2020 19:54:33 +0000
Subject: [PATCH 085/189] [Jenkins] auto-formatting by clang-format version
 5.0.0-3~16.04.1 (tags/RELEASE_500/final)

---
 stan/math/rev/functor/reduce_sum.hpp           | 6 +++---
 test/unit/math/rev/functor/reduce_sum_test.cpp | 1 -
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 3ec14934eec..e83e5213b10 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -153,10 +153,10 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
         // create a deep copy of all var's so that these are not
         // linked to any outer AD tree
         Vec local_sub_slice;
-	local_sub_slice.reserve(r.size());
+        local_sub_slice.reserve(r.size());
         for (int i = r.begin(); i < r.end(); ++i) {
           local_sub_slice.emplace_back(deep_copy(vmapped_[i]));
-	}
+        }
 
         auto args_tuple_local_copy = apply(
             [&](auto&&... args) {
@@ -177,7 +177,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
         sum_ += sub_sum_v.val();
 
         accumulate_adjoints(sliced_partials_ + r.begin(), local_sub_slice);
-	
+
         apply(
             [&](auto&&... args) {
               return accumulate_adjoints(args_adjoints_.data(), args...);
diff --git a/test/unit/math/rev/functor/reduce_sum_test.cpp b/test/unit/math/rev/functor/reduce_sum_test.cpp
index f7f43922801..e1f13ecbb15 100644
--- a/test/unit/math/rev/functor/reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/reduce_sum_test.cpp
@@ -65,7 +65,6 @@ TEST(v3_reduce_sum, gradient) {
   typedef boost::counting_iterator<std::size_t> count_iter;
   using stan::math::var;
 
-
   var lambda_v = lambda_d;
 
   std::vector<int> idata;

From 55171a4926adea247ecf4eeae939485c8ca85ee2 Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Thu, 5 Mar 2020 23:30:50 -0500
Subject: [PATCH 086/189] Adds pf (yes I know but seriously this time it's good
 I think) to the reduce_sum signatures

---
 make/compiler_flags                           |   4 +-
 stan/math/prim/functor/reduce_sum.hpp         |  41 +-
 stan/math/rev/functor/reduce_sum.hpp          | 373 +++++++++---------
 .../unit/math/mix/functor/reduce_sum_test.cpp |  52 +--
 .../math/prim/functor/reduce_sum_test.cpp     |  30 +-
 .../math/rev/functor/reduce_sum2_test.cpp     |  74 ++++
 .../unit/math/rev/functor/reduce_sum_test.cpp |  18 +-
 7 files changed, 325 insertions(+), 267 deletions(-)
 create mode 100644 test/unit/math/rev/functor/reduce_sum2_test.cpp

diff --git a/make/compiler_flags b/make/compiler_flags
index 929647ee77d..700c15533af 100644
--- a/make/compiler_flags
+++ b/make/compiler_flags
@@ -252,7 +252,7 @@ endif
 
 
 
-CXXFLAGS += $(CXXFLAGS_LANG) $(CXXFLAGS_OS) $(CXXFLAGS_WARNINGS) $(CXXFLAGS_BOOST) $(CXXFLAGS_EIGEN) $(CXXFLAGS_OPENCL) $(CXXFLAGS_MPI) $(CXXFLAGS_THREADS) $(CXXFLAGS_TBB) -O$(O) $(INC)
+CXXFLAGS += -fopenmp $(CXXFLAGS_LANG) $(CXXFLAGS_OS) $(CXXFLAGS_WARNINGS) $(CXXFLAGS_BOOST) $(CXXFLAGS_EIGEN) $(CXXFLAGS_OPENCL) $(CXXFLAGS_MPI) $(CXXFLAGS_THREADS) $(CXXFLAGS_TBB) -O$(O) $(INC)
 CPPFLAGS += $(CPPFLAGS_LANG) $(CPPFLAGS_OS) $(CPPFLAGS_WARNINGS) $(CPPFLAGS_BOOST) $(CPPFLAGS_EIGEN) $(CPPFLAGS_OPENCL) $(CPPFLAGS_MPI) $(CPPFLAGS_TBB)
 LDFLAGS += $(LDFLAGS_LANG) $(LDFLAGS_OS) $(LDFLAGS_WARNINGS) $(LDFLAGS_BOOST) $(LDFLAGS_EIGEN) $(LDFLAGS_OPENCL) $(LDFLAGS_MPI) $(LDFLAGS_TBB)
 LDLIBS += $(LDLIBS_LANG) $(LDLIBS_OS) $(LDLIBS_WARNINGS) $(LDLIBS_BOOST) $(LDLIBS_EIGEN) $(LDLIBS_OPENCL) $(LDLIBS_MPI) $(LDLIBS_TBB)
@@ -271,7 +271,7 @@ print-compiler-flags:
 	@echo '  - SUNDIALS                    ' $(SUNDIALS)
 	@echo '  - TBB                         ' $(TBB)
 	@echo '  - GTEST                       ' $(GTEST)
-	@echo '  - STAN_THREADS                ' $(STAN_THREADS) 
+	@echo '  - STAN_THREADS                ' $(STAN_THREADS)
 	@echo '  - STAN_OPENCL                 ' $(STAN_OPENCL)
 	@echo '  - STAN_MPI                    ' $(STAN_MPI)
 	@echo '  Compiler flags (each can be overriden separately):'
diff --git a/stan/math/prim/functor/reduce_sum.hpp b/stan/math/prim/functor/reduce_sum.hpp
index 890c53cb8c7..81177a6cf53 100644
--- a/stan/math/prim/functor/reduce_sum.hpp
+++ b/stan/math/prim/functor/reduce_sum.hpp
@@ -41,21 +41,19 @@ template <typename ReduceFunction, typename ReturnType, typename Vec,
 struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
                        ReturnType, Vec, Args...> {
   struct recursive_reducer {
-    using vmapped_t = Vec;
-    const vmapped_t& vmapped_;
+    Vec vmapped_;
     std::ostream* msgs_;
-    std::tuple<const Args&...> args_tuple_;
-    return_type_t<Vec, Args...> sum_;
-
-    recursive_reducer(const vmapped_t& vmapped, std::ostream* msgs,
-                      const Args&... args)
-        : vmapped_(vmapped), msgs_(msgs), args_tuple_(args...), sum_(0.0) {}
+    std::tuple<Args...> args_tuple_;
+    return_type_t<Vec, Args...> sum_{0.0};
+    template <typename VecT, typename... ArgsT>
+    recursive_reducer(VecT&& vmapped, std::ostream* msgs, ArgsT&&... args)
+        : vmapped_(std::forward<VecT>(vmapped)), msgs_(msgs),
+          args_tuple_(std::forward<ArgsT>(args)...) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
         : vmapped_(other.vmapped_),
           msgs_(other.msgs_),
-          args_tuple_(other.args_tuple_),
-          sum_(0.0) {}
+          args_tuple_(other.args_tuple_) {}
 
     void operator()(const tbb::blocked_range<size_t>& r) {
       if (r.empty()) {
@@ -67,7 +65,7 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
       auto end = vmapped_.begin();
       std::advance(end, r.end());
 
-      const vmapped_t sub_slice(start, end);
+      const std::decay_t<Vec> sub_slice(start, end);
 
       sum_ += apply(
           [&](auto&&... args) {
@@ -79,17 +77,19 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
 
     void join(const recursive_reducer& child) { sum_ += child.sum_; }
   };
-
-  return_type_t<Vec, Args...> operator()(const Vec& vmapped,
+  template <typename VecT, typename... ArgsT>
+  return_type_t<Vec, Args...> operator()(VecT&& vmapped,
                                          std::size_t grainsize,
                                          std::ostream* msgs,
-                                         const Args&... args) const {
+                                         ArgsT&&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
-    if (num_jobs == 0)
+    if (num_jobs == 0) {
       return 0.0;
+    }
 
-    recursive_reducer worker(vmapped, msgs, args...);
+    recursive_reducer worker(std::forward<VecT>(vmapped), msgs,
+     std::forward<ArgsT>(args)...);
 
 #ifdef STAN_DETERMINISTIC
     tbb::static_partitioner partitioner;
@@ -114,12 +114,13 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
  */
 template <typename ReduceFunction, typename Vec, require_vector_like_t<Vec>...,
           typename... Args>
-auto reduce_sum(const Vec& vmapped, std::size_t grainsize, std::ostream* msgs,
-                const Args&... args) {
+auto reduce_sum(Vec&& vmapped, std::size_t grainsize, std::ostream* msgs,
+                Args&&... args) {
   using return_type = return_type_t<Vec, Args...>;
   return internal::reduce_sum_impl<ReduceFunction, void, return_type, Vec,
-                                   Args...>()(vmapped, grainsize, msgs,
-                                              args...);
+                                   Args...>()(std::forward<Vec>(vmapped),
+                                              grainsize, msgs,
+                                              std::forward<Args>(args)...);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index e83e5213b10..8138f1219d6 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -22,172 +22,158 @@ template <typename ReduceFunction, typename ReturnType, typename Vec,
           typename... Args>
 struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
                        Vec, Args...> {
-  template <typename T, require_arithmetic_t<scalar_type_t<T>>...>
-  static inline const T& deep_copy(const T& arg) {
-    return arg;
-  }
 
-  static inline var deep_copy(const var& arg) {
-    return var(new vari(arg.val(), false));
-  }
 
-  static inline std::vector<var> deep_copy(const std::vector<var>& arg) {
-    std::vector<var> copy(arg.size());
-    for (size_t i = 0; i < arg.size(); ++i) {
-      copy[i] = new vari(arg[i].val(), false);
-    }
-    return copy;
-  }
+  struct recursive_reducer {
+    size_t num_shared_terms_;
+    double* sliced_partials_;
+    Vec vmapped_;
+    std::ostream* msgs_;
+    std::tuple<Args...> args_tuple_;
 
-  template <typename T, require_t<is_var<scalar_type_t<T>>>...>
-  static inline std::vector<T> deep_copy(const std::vector<T>& arg) {
-    std::vector<T> copy(arg.size());
-    for (size_t i = 0; i < arg.size(); ++i) {
-      copy[i] = deep_copy(arg[i]);
-    }
-    return copy;
-  }
+    double sum_{0.0};
+    Eigen::VectorXd args_adjoints_{0};
+    template <typename VecT, typename... ArgsT>
+    recursive_reducer(size_t num_shared_terms, double* sliced_partials,
+                      VecT&& vmapped, std::ostream* msgs,
+                      ArgsT&&... args)
+        : num_shared_terms_(num_shared_terms),
+          sliced_partials_(sliced_partials),
+          vmapped_(std::forward<VecT>(vmapped)),
+          msgs_(msgs),
+          args_tuple_(std::forward<ArgsT>(args)...) {}
+
+    recursive_reducer(recursive_reducer& other, tbb::split)
+        : num_shared_terms_(other.num_shared_terms_),
+          sliced_partials_(other.sliced_partials_),
+          vmapped_(other.vmapped_),
+          msgs_(other.msgs_),
+          args_tuple_(other.args_tuple_) {}
 
-  template <int RowType, int ColType>
-  static inline Eigen::Matrix<var, RowType, ColType> deep_copy(
-      const Eigen::Matrix<var, RowType, ColType>& arg) {
-    Eigen::Matrix<var, RowType, ColType> copy(arg.rows(), arg.cols());
-    for (size_t i = 0; i < arg.size(); ++i) {
-      copy(i) = new vari(arg(i).val(), false);
+    template <typename T, typename = require_arithmetic_t<scalar_type_t<T>>>
+    inline auto deep_copy(T arg) {
+      return arg;
     }
-    return copy;
-  }
 
-  // TODO(Steve): Move this somewhere smarter
-  // Fails to compile if type T does not have member operator(Integral)
-  template <typename T>
-  using operator_paren_access_t = decltype(std::declval<T>()(int{}));
+    inline auto deep_copy(const var& arg) {
+      return var(new vari(arg.val(), false));
+    }
 
-  template <typename... Pargs>
-  static double* accumulate_adjoints(double* dest, const var& x,
-                                     const Pargs&... args) {
-    *dest += x.adj();
-    return accumulate_adjoints(dest + 1, args...);
-  }
+    template <typename VarVec, require_std_vector_vt<is_var, VarVec>* = nullptr>
+    inline auto deep_copy(VarVec&& arg) {
+      std::vector<var> copy_vec(arg.size());
+      for (size_t i = 0; i < arg.size(); ++i) {
+        copy_vec[i] = new vari(arg[i].val(), false);
+      }
+      return copy_vec;
+    }
 
-  template <typename... Pargs>
-  static double* accumulate_adjoints(double* dest, const std::vector<var>& x,
-                                     const Pargs&... args) {
-    for (size_t i = 0; i < x.size(); ++i) {
-      dest[i] += x[i].adj();
+    template <typename VarVec, require_std_vector_st<is_var, VarVec>* = nullptr,
+              require_std_vector_vt<is_container, VarVec>* = nullptr>
+    inline auto deep_copy(VarVec&& arg) {
+      std::vector<value_type_t<VarVec>> copy_vec(arg.size());
+      for (size_t i = 0; i < arg.size(); ++i) {
+        copy_vec[i] = deep_copy(arg[i]);
+      }
+      return copy_vec;
     }
-    return accumulate_adjoints(dest + x.size(), args...);
-  }
 
-  template <typename T, require_t<is_var<scalar_type_t<T>>>...,
-            require_not_t<is_var<T>>..., typename... Pargs>
-  static double* accumulate_adjoints(double* dest, const std::vector<T>& x,
-                                     const Pargs&... args) {
-    for (size_t i = 0; i < x.size(); ++i) {
-      dest = accumulate_adjoints(dest, x[i]);
+    template <typename Mat, require_eigen_vt<is_var, Mat>* = nullptr>
+    inline auto deep_copy(Mat&& arg) {
+      return arg.unaryExpr([](auto&& x) {
+         return var(new vari(x.val(), false));
+       }).eval();;
     }
-    return accumulate_adjoints(dest, args...);
-  }
 
-  // Works on anything with a operator()
-  template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
-  static double* accumulate_adjoints(double* dest, const Mat& x,
-                                     const Pargs&... args) {
-    for (size_t i = 0; i < x.size(); ++i) {
-      dest[i] += x(i).adj();
+    template <typename... Pargs>
+    inline double* accumulate_adjoints(double* dest, const var& x,
+                                       Pargs&&... args) {
+      *dest += x.adj();
+      return accumulate_adjoints(dest + 1, std::forward<Pargs>(args)...);
     }
-    return accumulate_adjoints(dest + x.size(), args...);
-  }
 
-  // Anything with a scalar type of Arithmetic gets tossed
-  template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>...,
-            typename... Pargs>
-  static double* accumulate_adjoints(double* dest, Arith&& x,
-                                     const Pargs&... args) {
-    return accumulate_adjoints(dest, args...);
-  }
+    template <typename VarVec, require_std_vector_vt<is_var, VarVec>* = nullptr, typename... Pargs>
+    inline double* accumulate_adjoints(double* dest, VarVec&& x,
+                                       Pargs&&... args) {
+      for (auto&& x_iter : x) {
+        *dest += x_iter.adj();
+        ++dest;
+      }
+      return accumulate_adjoints(dest, std::forward<Pargs>(args)...);
+    }
 
-  static double* accumulate_adjoints(double* x) { return x; }
+    template <typename VecContainer,
+        require_std_vector_st<is_var, VecContainer>* = nullptr,
+        require_std_vector_vt<is_container, VecContainer>* = nullptr,
+              typename... Pargs>
+    inline double* accumulate_adjoints(double* dest, VecContainer&& x,
+                                       Pargs&&... args) {
+      for (auto&& x_iter : x) {
+        dest = accumulate_adjoints(dest, x_iter);
+      }
+      return accumulate_adjoints(dest, std::forward<Pargs>(args)...);
+    }
 
-  struct recursive_reducer {
-    size_t num_shared_terms_;
-    double* sliced_partials_;
-    const Vec& vmapped_;
-    std::ostream* msgs_;
-    std::tuple<const Args&...> args_tuple_;
+    template <typename Mat, require_eigen_vt<is_var, Mat>* = nullptr,
+              typename... Pargs>
+    inline double* accumulate_adjoints(double* dest, const Mat& x,
+                                       Pargs&&... args) {
+      Eigen::Map<Eigen::MatrixXd>(dest, x.rows(), x.cols()) += x.adj();
+      return accumulate_adjoints(dest + x.size(), std::forward<Pargs>(args)...);
+    }
 
-    double sum_;
-    Eigen::VectorXd args_adjoints_;
+    template <typename Arith,
+              require_arithmetic_t<scalar_type_t<Arith>>* = nullptr,
+              typename... Pargs>
+    inline double* accumulate_adjoints(double* dest, Arith&& x,
+                                       Pargs&&... args) {
+      return accumulate_adjoints(dest, std::forward<Pargs>(args)...);
+    }
 
-    recursive_reducer(size_t num_shared_terms, double* sliced_partials,
-                      const Vec& vmapped, std::ostream* msgs,
-                      const Args&... args)
-        : num_shared_terms_(num_shared_terms),
-          sliced_partials_(sliced_partials),
-          vmapped_(vmapped),
-          msgs_(msgs),
-          args_tuple_(args...),
-          sum_(0.0),
-          args_adjoints_(0) {}
+    inline double* accumulate_adjoints(double* x) { return x; }
 
-    recursive_reducer(recursive_reducer& other, tbb::split)
-        : num_shared_terms_(other.num_shared_terms_),
-          sliced_partials_(other.sliced_partials_),
-          vmapped_(other.vmapped_),
-          msgs_(other.msgs_),
-          args_tuple_(other.args_tuple_),
-          sum_(0.0),
-          args_adjoints_(0) {}
 
-    void operator()(const tbb::blocked_range<size_t>& r) {
+    void operator()(const tbb::blocked_range<size_t>& r) try {
       if (r.empty())
         return;
 
       if (args_adjoints_.size() == 0) {
-        args_adjoints_ = Eigen::VectorXd::Zero(num_shared_terms_);
+        args_adjoints_ = Eigen::VectorXd::Zero(this->num_shared_terms_);
       }
 
-      try {
-        start_nested();
-
-        // create a deep copy of all var's so that these are not
-        // linked to any outer AD tree
-        Vec local_sub_slice;
-        local_sub_slice.reserve(r.size());
-        for (int i = r.begin(); i < r.end(); ++i) {
-          local_sub_slice.emplace_back(deep_copy(vmapped_[i]));
-        }
-
-        auto args_tuple_local_copy = apply(
-            [&](auto&&... args) {
-              return std::tuple<decltype(deep_copy(args))...>(
-                  deep_copy(args)...);
-            },
-            args_tuple_);
-
-        var sub_sum_v = apply(
-            [&](auto&&... args) {
-              return ReduceFunction()(r.begin(), r.end() - 1, local_sub_slice,
-                                      msgs_, args...);
-            },
-            args_tuple_local_copy);
-
-        sub_sum_v.grad();
-
-        sum_ += sub_sum_v.val();
-
-        accumulate_adjoints(sliced_partials_ + r.begin(), local_sub_slice);
-
-        apply(
-            [&](auto&&... args) {
-              return accumulate_adjoints(args_adjoints_.data(), args...);
-            },
-            args_tuple_local_copy);
-      } catch (const std::exception& e) {
-        recover_memory_nested();
-        throw;
+      start_nested();
+      // create a deep copy of all var's so that these are not
+      // linked to any outer AD tree
+      std::decay_t<Vec> local_sub_slice;
+      local_sub_slice.reserve(r.size());
+      for (int i = r.begin(); i < r.end(); ++i) {
+        local_sub_slice.emplace_back(deep_copy(vmapped_[i]));
       }
+      auto args_tuple_local_copy = apply(
+          [&](auto&&... args) {
+            return std::tuple<decltype(deep_copy(args))...>(
+                deep_copy(args)...);
+          },
+          this->args_tuple_);
+      var sub_sum_v = apply(
+          [&](auto&&... args) {
+            return ReduceFunction()(r.begin(), r.end() - 1, local_sub_slice,
+                                    this->msgs_, args...);
+          },
+          args_tuple_local_copy);
+      sub_sum_v.grad();
+      sum_ += sub_sum_v.val();
+      accumulate_adjoints(this->sliced_partials_ + r.begin(), local_sub_slice);
+      apply(
+          [&](auto&&... args) {
+            return accumulate_adjoints(args_adjoints_.data(),
+             std::forward<decltype(args)>(args)...);
+          },
+          std::move(args_tuple_local_copy));
+      recover_memory_nested();
+    } catch (const std::exception& e) {
       recover_memory_nested();
+      throw;
     }
 
     void join(const recursive_reducer& rhs) {
@@ -200,42 +186,38 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     }
   };
 
-  // Fails to compile if type T does not have callable member size()
-  template <typename T>
-  using member_size_t = decltype(std::declval<T>().size());
-
   template <typename... Pargs>
   size_t count_var_impl(size_t count, const std::vector<var>& x,
-                        const Pargs&... args) const {
-    return count_var_impl(count + x.size(), args...);
+                        Pargs&&... args) const {
+    return count_var_impl(count + x.size(), std::forward<Pargs>(args)...);
   }
 
-  template <typename T, require_t<is_var<scalar_type_t<T>>>...,
-            require_not_t<is_var<T>>..., typename... Pargs>
-  size_t count_var_impl(size_t count, const std::vector<T>& x,
-                        const Pargs&... args) const {
+  template <typename T, require_std_vector_st<is_var, T>* = nullptr,
+            require_std_vector_vt<is_container, T>* = nullptr,
+            typename... Pargs>
+  size_t count_var_impl(size_t count, T&& x, Pargs&&... args) const {
     for (size_t i = 0; i < x.size(); i++) {
       count = count_var_impl(count, x[i]);
     }
-    return count_var_impl(count, args...);
+    return count_var_impl(count, std::forward<Pargs>(args)...);
   }
 
-  template <typename Mat, require_eigen_vt<is_var, Mat>..., typename... Pargs>
-  size_t count_var_impl(size_t count, const Mat& x,
-                        const Pargs&... args) const {
-    return count_var_impl(count + x.size(), args...);
+  template <typename Mat, require_eigen_vt<is_var, Mat>* = nullptr,
+            typename... Pargs>
+  size_t count_var_impl(size_t count, Mat&& x, Pargs&&... args) const {
+    return count_var_impl(count + x.size(), std::forward<Pargs>(args)...);
   }
 
   template <typename... Pargs>
-  size_t count_var_impl(size_t count, const var& x,
-                        const Pargs&... args) const {
-    return count_var_impl(count + 1, args...);
+  size_t count_var_impl(size_t count, const var& x, Pargs&&... args) const {
+    return count_var_impl(count + 1, std::forward<Pargs>(args)...);
   }
 
-  template <typename... Pargs, typename Arith,
-            require_arithmetic_t<scalar_type_t<Arith>>...>
-  size_t count_var_impl(size_t count, Arith& x, const Pargs&... args) const {
-    return count_var_impl(count, args...);
+  template <typename Arith,
+            require_arithmetic_t<scalar_type_t<Arith>>* = nullptr,
+            typename... Pargs>
+  size_t count_var_impl(size_t count, Arith& x, Pargs&&... args) const {
+    return count_var_impl(count, std::forward<Pargs>(args)...);
   }
 
   size_t count_var_impl(size_t count) const { return count; }
@@ -247,53 +229,57 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
    * @return Number of scalars of type T in input
    */
   template <typename... Pargs>
-  size_t count_var(const Pargs&... args) const {
-    return count_var_impl(0, args...);
+  size_t count_var(Pargs&&... args) const {
+    return count_var_impl(0, std::forward<Pargs>(args)...);
   }
 
   template <typename... Pargs>
-  vari** save_varis(vari** dest, const var& x, const Pargs&... args) const {
+  vari** save_varis(vari** dest, const var& x, Pargs&&... args) const {
     *dest = x.vi_;
-    return save_varis(dest + 1, args...);
+    return save_varis(dest + 1, std::forward<Pargs>(args)...);
   }
 
-  template <typename... Pargs>
-  vari** save_varis(vari** dest, const std::vector<var>& x,
-                    const Pargs&... args) const {
-    for (size_t i = 0; i < x.size(); ++i) {
-      dest[i] = x[i].vi_;
-    }
-    return save_varis(dest + x.size(), args...);
+  template <typename VarVec, require_std_vector_vt<is_var, VarVec>* = nullptr,
+            typename... Pargs>
+  vari** save_varis(vari** dest, VarVec&& x, Pargs&&... args) const {
+    using write_map = Eigen::Map<Eigen::Matrix<vari*, -1, 1>>;
+    using read_map = Eigen::Map<const Eigen::Matrix<var, -1, 1>>;
+    write_map(dest, x.size(), 1) = read_map(x.data(), x.size(), 1).vi();
+    return save_varis(dest + x.size(), std::forward<Pargs>(args)...);
   }
 
-  template <typename T, require_t<is_var<scalar_type_t<T>>>...,
-            require_not_t<is_var<T>>..., typename... Pargs>
-  vari** save_varis(vari** dest, const std::vector<T>& x,
-                    const Pargs&... args) const {
+  template <typename VecContainer,
+            require_std_vector_st<is_var, VecContainer>* = nullptr,
+            require_std_vector_vt<is_container, VecContainer>* = nullptr,
+            typename... Pargs>
+  vari** save_varis(vari** dest, VecContainer&& x, Pargs&&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest = save_varis(dest, x[i]);
     }
-    return save_varis(dest, args...);
+    return save_varis(dest, std::forward<Pargs>(args)...);
   }
 
-  template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
-  vari** save_varis(vari** dest, const Mat& x, const Pargs&... args) const {
-    for (size_t i = 0; i < x.size(); ++i) {
-      dest[i] = x(i).vi_;
-    }
-    return save_varis(dest + x.size(), args...);
+  template <typename Mat, require_eigen_vt<is_var, Mat>* = nullptr,
+            typename... Pargs>
+  vari** save_varis(vari** dest, Mat&& x, Pargs&&... args) const {
+    using write_map = Eigen::Map<Eigen::Matrix<vari*,
+     std::decay_t<Mat>::RowsAtCompileTime,
+     std::decay_t<Mat>::ColsAtCompileTime>>;
+    write_map(dest, x.rows(), x.cols()) = x.vi();
+    return save_varis(dest + x.size(), std::forward<Pargs>(args)...);
   }
 
-  template <typename R, require_arithmetic_t<scalar_type_t<R>>...,
+  template <typename R, require_arithmetic_t<scalar_type_t<R>>* = nullptr,
             typename... Pargs>
-  vari** save_varis(vari** dest, const R& x, const Pargs&... args) const {
-    return save_varis(dest, args...);
+  vari** save_varis(vari** dest, R&& x, Pargs&&... args) const {
+    return save_varis(dest, std::forward<Pargs>(args)...);
   }
 
   vari** save_varis(vari** dest) const { return dest; }
 
-  var operator()(const Vec& vmapped, std::size_t grainsize, std::ostream* msgs,
-                 const Args&... args) const {
+  template <typename VecT, typename... ArgsT>
+  var operator()(VecT&& vmapped, std::size_t grainsize, std::ostream* msgs,
+                 ArgsT&&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
     if (num_jobs == 0)
@@ -309,14 +295,11 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
 
     for (size_t i = 0; i < num_sliced_terms; ++i)
       partials[i] = 0.0;
-
-    double sum = 0;
-
     recursive_reducer worker(num_shared_terms, partials, vmapped, msgs,
                              args...);
 
 #ifdef STAN_DETERMINISTIC
-    tbb::static_partitioner partitioner;
+    tbb::inline_partitioner partitioner;
     tbb::parallel_deterministic_reduce(
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker,
         partitioner);
@@ -325,17 +308,15 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
 #endif
 
-    save_varis(varis, vmapped);
-    save_varis(varis + num_sliced_terms, args...);
+    save_varis(varis, std::forward<VecT>(vmapped));
+    save_varis(varis + num_sliced_terms, std::forward<ArgsT>(args)...);
 
     for (size_t i = 0; i < num_shared_terms; ++i) {
       partials[num_sliced_terms + i] = worker.args_adjoints_(i);
     }
 
-    sum = worker.sum_;
-
     return var(new precomputed_gradients_vari(
-        sum, num_sliced_terms + num_shared_terms, varis, partials));
+        worker.sum_, num_sliced_terms + num_shared_terms, varis, partials));
   }
 };
 }  // namespace internal
diff --git a/test/unit/math/mix/functor/reduce_sum_test.cpp b/test/unit/math/mix/functor/reduce_sum_test.cpp
index fd1638db18a..88f54714ccc 100644
--- a/test/unit/math/mix/functor/reduce_sum_test.cpp
+++ b/test/unit/math/mix/functor/reduce_sum_test.cpp
@@ -1,22 +1,24 @@
+#include <stan/math/prim/meta.hpp>
 #include <test/unit/math/test_ad.hpp>
+
 #include <limits>
 #include <vector>
 
 std::ostream* msgs = nullptr;
 
-template <typename T>
+template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
 T sum_(T arg) {
   return arg;
 }
 
-template <typename T, int RowType, int ColType>
-auto sum_(const Eigen::Matrix<T, RowType, ColType>& arg) {
+template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
+auto sum_(EigMat&& arg) {
   return stan::math::sum(arg);
 }
 
-template <typename T>
-auto sum_(const std::vector<T>& arg) {
-  stan::scalar_type_t<T> sum = 0;
+template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
+auto sum_(Vec&& arg) {
+  stan::scalar_type_t<Vec> sum = 0;
   for (size_t i = 0; i < arg.size(); ++i) {
     sum += sum_(arg[i]);
   }
@@ -26,19 +28,19 @@ auto sum_(const std::vector<T>& arg) {
 struct sum_lpdf {
   template <typename T, typename... Args>
   inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<T>& sub_slice, std::ostream* msgs,
-                         const Args&... args) const {
+                         T&& sub_slice, std::ostream* msgs,
+                         Args&&... args) const {
     using return_type = stan::return_type_t<T, Args...>;
 
     return stan::math::sum(sub_slice)
            + sub_slice.size()
                  * stan::math::sum(
-                       std::vector<return_type>{return_type(sum_(args))...});
+                       std::vector<return_type>{return_type(sum_(std::forward<Args>(args)))...});
   }
 };
 
 TEST(MathMix_reduce_sum, double_slice) {
-  auto f = [](const auto& data) {
+  auto f = [](auto&& data) {
     return stan::math::reduce_sum<sum_lpdf>(data, 0, msgs);
   };
 
@@ -48,11 +50,11 @@ TEST(MathMix_reduce_sum, double_slice) {
 }
 
 struct start_end_lpdf {
-  template <typename T>
+  template <typename T1, typename T2>
   inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<T>&, std::ostream* msgs,
-                         const std::vector<T>& data) const {
-    T sum = 0;
+                         T1&&, std::ostream* msgs,
+                         T2&& data) const {
+    stan::return_type_t<T1, T2> sum = 0;
     EXPECT_GE(start, 0);
     EXPECT_LE(end, data.size() - 1);
     for (size_t i = start; i <= end; i++) {
@@ -63,7 +65,7 @@ struct start_end_lpdf {
 };
 
 TEST(StanMath_reduce_sum, start_end_slice) {
-  auto start_end = [](const auto& arg) {
+  auto start_end = [](auto&& arg) {
     return stan::math::reduce_sum<start_end_lpdf>(arg, 0, msgs, arg);
   };
 
@@ -72,12 +74,12 @@ TEST(StanMath_reduce_sum, start_end_slice) {
   stan::test::expect_ad(start_end, data);
 }
 
-auto fi = [](const auto&... args) {
+auto fi = [](auto&&... args) {
   return stan::math::reduce_sum<sum_lpdf>(std::vector<int>(2, 10.0), 0, msgs,
                                           args...);
 };
 
-auto fd = [](const auto& data, const auto&... args) {
+auto fd = [](auto&& data, auto&&... args) {
   return stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, args...);
 };
 
@@ -85,7 +87,7 @@ TEST(MathMix_reduce_sum, int_arg) {
   std::vector<double> data(2, 1.0);
   int arg = 5.0;
 
-  stan::test::expect_ad([&](const auto& data) { return fd(data, arg); }, data);
+  stan::test::expect_ad([&](auto&& data) { return fd(data, arg); }, data);
 }
 
 TEST(MathMix_reduce_sum, double_arg) {
@@ -100,7 +102,7 @@ TEST(MathMix_reduce_sum, std_vector_int_arg) {
   std::vector<double> data(2, 10.0);
   std::vector<int> arg(2, 10);
 
-  stan::test::expect_ad([&](const auto& data) { return fd(data, arg); }, data);
+  stan::test::expect_ad([&](auto&& data) { return fd(data, arg); }, data);
 }
 
 TEST(MathMix_reduce_sum, std_vector_double_arg) {
@@ -181,7 +183,7 @@ TEST(MathMix_reduce_sum, eigen_three_args_with_ints1) {
   Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
 
   stan::test::expect_ad(
-      [&](const auto& arg1, const auto& arg2, const auto& arg3) {
+      [&](auto&& arg1, auto&& arg2, auto&& arg3) {
         return fi(1, arg1, std::vector<int>{1, 2, 3}, arg2, 3, arg3);
       },
       arg1, arg2, arg3);
@@ -193,7 +195,7 @@ TEST(MathMix_reduce_sum, eigen_three_args_with_ints2) {
   Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
 
   stan::test::expect_ad(
-      [&](const auto& arg1, const auto& arg2, const auto& arg3) {
+    [&](auto&& arg1, auto&& arg2, auto&& arg3) {
         return fi(1, arg1, std::vector<int>{1, 2, 3}, arg2, 3, arg3);
       },
       arg1, arg2, arg3);
@@ -205,7 +207,7 @@ TEST(MathMix_reduce_sum, eigen_three_args_with_ints3) {
   std::vector<Eigen::MatrixXd> arg3(2, Eigen::MatrixXd::Ones(2, 2));
 
   stan::test::expect_ad(
-      [&](const auto& arg1, const auto& arg2, const auto& arg3) {
+      [&](auto&& arg1, auto&& arg2, auto&& arg3) {
         return fi(1, arg1, std::vector<int>{1, 2, 3}, arg2, 3, arg3);
       },
       arg1, arg2, arg3);
@@ -217,7 +219,7 @@ TEST(MathMix_reduce_sum, eigen_three_args_with_doubles1) {
   Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
 
   stan::test::expect_ad(
-      [&](const auto& arg1, const auto& arg2, const auto& arg3) {
+      [&](auto&& arg1, auto&& arg2, auto&& arg3) {
         return fi(std::vector<double>{1.0, 2.0, 3.0}, arg1, 3.0, arg2,
                   std::vector<double>{1.0, 2.0, 3.0}, arg3);
       },
@@ -230,7 +232,7 @@ TEST(MathMix_reduce_sum, eigen_three_args_with_doubles2) {
   Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
 
   stan::test::expect_ad(
-      [&](const auto& arg1, const auto& arg2, const auto& arg3) {
+      [&](auto&& arg1, auto&& arg2, auto&& arg3) {
         return fi(std::vector<double>{1.0, 2.0, 3.0}, arg1, 3.0, arg2,
                   std::vector<double>{1.0, 2.0, 3.0}, arg3);
       },
@@ -243,7 +245,7 @@ TEST(MathMix_reduce_sum, eigen_three_args_with_doubles3) {
   std::vector<Eigen::MatrixXd> arg3(2, Eigen::MatrixXd::Ones(2, 2));
 
   stan::test::expect_ad(
-      [&](const auto& arg1, const auto& arg2, const auto& arg3) {
+      [&](auto&& arg1, auto&& arg2, auto&& arg3) {
         return fi(std::vector<double>{1.0, 2.0, 3.0}, arg1, 3.0, arg2,
                   std::vector<double>{1.0, 2.0, 3.0}, arg3);
       },
diff --git a/test/unit/math/prim/functor/reduce_sum_test.cpp b/test/unit/math/prim/functor/reduce_sum_test.cpp
index 3c62280fa34..63c248452e0 100644
--- a/test/unit/math/prim/functor/reduce_sum_test.cpp
+++ b/test/unit/math/prim/functor/reduce_sum_test.cpp
@@ -23,7 +23,7 @@ struct count_lpdf {
   }
 };
 
-TEST(StanMath_reduce_sum, value) {
+TEST(StanMathPrim_reduce_sum, value) {
   stan::math::init_threadpool_tbb();
 
   double lambda_d = 10.0;
@@ -65,7 +65,7 @@ struct nesting_count_lpdf {
   }
 };
 
-TEST(StanMath_reduce_sum, nesting_value) {
+TEST(StanMathPrim_reduce_sum, nesting_value) {
   stan::math::init_threadpool_tbb();
 
   double lambda_d = 10.0;
@@ -105,7 +105,7 @@ struct double_slice_lpdf {
   }
 };
 
-TEST(StanMath_reduce_sum, int_slice) {
+TEST(StanMathPrim_reduce_sum, int_slice) {
   stan::math::init_threadpool_tbb();
 
   std::vector<int> data(5, 10);
@@ -113,7 +113,7 @@ TEST(StanMath_reduce_sum, int_slice) {
   EXPECT_EQ(50, stan::math::reduce_sum<int_slice_lpdf>(data, 0, msgs));
 }
 
-TEST(StanMath_reduce_sum, double_slice) {
+TEST(StanMathPrim_reduce_sum, double_slice) {
   stan::math::init_threadpool_tbb();
 
   std::vector<double> data(5, 10.0);
@@ -136,7 +136,7 @@ struct start_end_lpdf {
   }
 };
 
-TEST(StanMath_reduce_sum, start_end_slice) {
+TEST(StanMathPrim_reduce_sum, start_end_slice) {
   stan::math::init_threadpool_tbb();
 
   std::vector<int> data(5, 10);
@@ -203,7 +203,7 @@ struct eigen_matrix_arg_lpdf {
   }
 };
 
-TEST(StanMath_reduce_sum, int_arg) {
+TEST(StanMathPrim_reduce_sum, int_arg) {
   stan::math::init_threadpool_tbb();
 
   std::vector<double> data(5, 10.0);
@@ -213,7 +213,7 @@ TEST(StanMath_reduce_sum, int_arg) {
                    stan::math::reduce_sum<int_arg_lpdf>(data, 0, msgs, arg));
 }
 
-TEST(StanMath_reduce_sum, double_arg) {
+TEST(StanMathPrim_reduce_sum, double_arg) {
   stan::math::init_threadpool_tbb();
 
   std::vector<double> data(5, 10.0);
@@ -223,7 +223,7 @@ TEST(StanMath_reduce_sum, double_arg) {
                    stan::math::reduce_sum<double_arg_lpdf>(data, 0, msgs, arg));
 }
 
-TEST(StanMath_reduce_sum, std_vector_int_arg) {
+TEST(StanMathPrim_reduce_sum, std_vector_int_arg) {
   stan::math::init_threadpool_tbb();
 
   std::vector<double> data(5, 10.0);
@@ -234,7 +234,7 @@ TEST(StanMath_reduce_sum, std_vector_int_arg) {
       stan::math::reduce_sum<std_vector_int_arg_lpdf>(data, 0, msgs, arg));
 }
 
-TEST(StanMath_reduce_sum, std_vector_double_arg) {
+TEST(StanMathPrim_reduce_sum, std_vector_double_arg) {
   stan::math::init_threadpool_tbb();
 
   std::vector<double> data(5, 10.0);
@@ -245,7 +245,7 @@ TEST(StanMath_reduce_sum, std_vector_double_arg) {
       stan::math::reduce_sum<std_vector_double_arg_lpdf>(data, 0, msgs, arg));
 }
 
-TEST(StanMath_reduce_sum, eigen_vector_arg) {
+TEST(StanMathPrim_reduce_sum, eigen_vector_arg) {
   stan::math::init_threadpool_tbb();
 
   std::vector<double> data(5, 10.0);
@@ -255,7 +255,7 @@ TEST(StanMath_reduce_sum, eigen_vector_arg) {
                                      data, 0, msgs, arg));
 }
 
-TEST(StanMath_reduce_sum, eigen_row_vector_arg) {
+TEST(StanMathPrim_reduce_sum, eigen_row_vector_arg) {
   stan::math::init_threadpool_tbb();
 
   std::vector<double> data(5, 10.0);
@@ -266,7 +266,7 @@ TEST(StanMath_reduce_sum, eigen_row_vector_arg) {
       stan::math::reduce_sum<eigen_row_vector_arg_lpdf>(data, 0, msgs, arg));
 }
 
-TEST(StanMath_reduce_sum, eigen_matrix_arg) {
+TEST(StanMathPrim_reduce_sum, eigen_matrix_arg) {
   stan::math::init_threadpool_tbb();
 
   std::vector<double> data(5, 10.0);
@@ -301,7 +301,7 @@ struct std_vector_eigen_vector_arg_lpdf {
   }
 };
 
-TEST(StanMath_reduce_sum, std_vector_std_vector_double_arg) {
+TEST(StanMathPrim_reduce_sum, std_vector_std_vector_double_arg) {
   stan::math::init_threadpool_tbb();
 
   std::vector<double> data(5, 10.0);
@@ -313,7 +313,7 @@ TEST(StanMath_reduce_sum, std_vector_std_vector_double_arg) {
                                                                     msgs, arg));
 }
 
-TEST(StanMath_reduce_sum, std_vector_eigen_vector_arg) {
+TEST(StanMathPrim_reduce_sum, std_vector_eigen_vector_arg) {
   stan::math::init_threadpool_tbb();
 
   std::vector<double> data(5, 10.0);
@@ -346,7 +346,7 @@ struct sum_lpdf {
   }
 };
 
-TEST(StanMath_reduce_sum, sum) {
+TEST(StanMathPrim_reduce_sum, sum) {
   stan::math::init_threadpool_tbb();
 
   std::vector<double> data(5, 1.0);
diff --git a/test/unit/math/rev/functor/reduce_sum2_test.cpp b/test/unit/math/rev/functor/reduce_sum2_test.cpp
new file mode 100644
index 00000000000..14b0b82b6d9
--- /dev/null
+++ b/test/unit/math/rev/functor/reduce_sum2_test.cpp
@@ -0,0 +1,74 @@
+#include <stan/math/prim/core.hpp>
+#include <stan/math.hpp>
+#include <gtest/gtest.h>
+#include <algorithm>
+#include <sstream>
+#include <tuple>
+#include <vector>
+
+std::ostream* msgs = nullptr;
+
+template <typename T>
+struct count_lpdf {
+  count_lpdf() {}
+  template <typename Vec>
+  inline auto operator()(std::size_t start, std::size_t end,
+                      Vec&& sub_slice, std::ostream* msgs,
+                      const T& lambda,
+                      int N) const {
+    using stan::math::var;
+
+    var sum = 0.0;
+    for(int j = start; j < end; j++) {
+      var lambda_mult = sub_slice[j - start] * lambda;
+      for(int i = 0; i < N; i++) {
+        sum += lambda_mult;
+        lambda_mult *= lambda;
+      }
+    }
+
+    return sum;
+  }
+};
+
+TEST(v3_reduce_sum_benchmarks, reduce_sum_small) {
+  using stan::math::var;
+
+  stan::math::init_threadpool_tbb();
+
+  std::vector<int> datasizes = { 1024, 4096, 16384 };
+  std::vector<size_t> grainsizes = { 8, 16, 32, 64, 128, 256 };
+  std::vector<int> worksizes = { 8, 16, 32, 64, 128, 256 };
+
+  std::cout << "which_parallel, datasize, grainsize, worksize, time" << std::endl;
+  for(auto datasize : datasizes) {
+      for(auto worksize : worksizes) {
+        for(auto grainsize : grainsizes) {
+          std::vector<int> data(datasize, 1);
+
+          var lambda_v = 0.5;
+
+          double begin_norm_time = omp_get_wtime();
+          var poisson_lpdf2 = 0.0;
+          for(int i = 0; i < 100; i++) {
+            poisson_lpdf2 += count_lpdf<var>()(0, data.size(), data, msgs, lambda_v, worksize);
+          }
+          double end_norm_time = omp_get_wtime();
+          std::cout << "normie, " << datasize << ", " << grainsize <<
+            ", " << worksize << ", " << end_norm_time - begin_norm_time << std::endl;
+
+          double begin_par_time = omp_get_wtime();
+          var poisson_lpdf = 0.0;
+          for(int i = 0; i < 100; i++) {
+            poisson_lpdf += stan::math::reduce_sum<count_lpdf<var>>(data, grainsize, msgs, lambda_v, worksize);
+          }
+          double end_par_time = omp_get_wtime();
+          std::cout << "reduce_sum, " << datasize << ", " << grainsize <<
+            ", " << worksize << ", " << end_par_time - begin_par_time << std::endl;
+          stan::math::recover_memory();
+        }
+    }
+  }
+
+  stan::math::recover_memory();
+}
diff --git a/test/unit/math/rev/functor/reduce_sum_test.cpp b/test/unit/math/rev/functor/reduce_sum_test.cpp
index e1f13ecbb15..e5a2b9387f0 100644
--- a/test/unit/math/rev/functor/reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/reduce_sum_test.cpp
@@ -23,7 +23,7 @@ struct count_lpdf {
   }
 };
 
-TEST(v3_reduce_sum, value) {
+TEST(StanMathRev_reduce_sum, value) {
   stan::math::init_threadpool_tbb();
 
   double lambda_d = 10.0;
@@ -51,7 +51,7 @@ TEST(v3_reduce_sum, value) {
   std::cout << "value of poisson lpdf : " << poisson_lpdf << std::endl;
 }
 
-TEST(v3_reduce_sum, gradient) {
+TEST(StanMathRev_reduce_sum, gradient) {
   stan::math::init_threadpool_tbb();
 
   double lambda_d = 10.0;
@@ -116,7 +116,7 @@ struct nesting_count_lpdf {
   }
 };
 
-TEST(v3_reduce_sum, nesting_gradient) {
+TEST(StanMathRev_reduce_sum, nesting_gradient) {
   stan::math::init_threadpool_tbb();
 
   double lambda_d = 10.0;
@@ -175,12 +175,12 @@ struct grouped_count_lpdf {
   // does the reduction in the sub-slice start to end
   template <typename VecInt1, typename VecT, typename VecInt2>
   inline T operator()(std::size_t start, std::size_t end,
-                      const VecInt1& sub_slice, std::ostream* msgs,
-                      const VecT& lambda, const VecInt2& gidx) const {
+                      VecInt1&& sub_slice, std::ostream* msgs,
+                      VecT&& lambda, VecInt2&& gidx) const {
     const std::size_t num_terms = end - start + 1;
     // std::cout << "sub-slice " << start << " - " << end << "; num_terms = " <<
     // num_terms << "; size = " << sub_slice.size() << std::endl;
-    VecT lambda_slice(num_terms);
+    std::decay_t<VecT> lambda_slice(num_terms);
     for (std::size_t i = 0; i != num_terms; ++i)
       lambda_slice[i] = lambda[gidx[start + i]];
 
@@ -188,7 +188,7 @@ struct grouped_count_lpdf {
   }
 };
 
-TEST(v3_reduce_sum, grouped_gradient) {
+TEST(StanMathRev_reduce_sum, grouped_gradient) {
   stan::math::init_threadpool_tbb();
 
   double lambda_d = 10.0;
@@ -247,7 +247,7 @@ TEST(v3_reduce_sum, grouped_gradient) {
   stan::math::recover_memory();
 }
 
-TEST(v3_reduce_sum, grouped_gradient_eigen) {
+TEST(StanMathRev_reduce_sum, grouped_gradient_eigen) {
   stan::math::init_threadpool_tbb();
 
   double lambda_d = 10.0;
@@ -329,7 +329,7 @@ struct slice_group_count_lpdf {
   }
 };
 
-TEST(v3_reduce_sum, slice_group_gradient) {
+TEST(StanMathRev_reduce_sum, slice_group_gradient) {
   stan::math::init_threadpool_tbb();
 
   double lambda_d = 10.0;

From bc3b7c6784d7b4744a7acdd0cf7314530e9ffd9d Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Fri, 6 Mar 2020 10:55:36 -0500
Subject: [PATCH 087/189] add inline to functions

---
 stan/math/rev/functor/reduce_sum.hpp          | 30 ++++----
 .../math/rev/functor/reduce_sum2_test.cpp     | 74 -------------------
 2 files changed, 15 insertions(+), 89 deletions(-)
 delete mode 100644 test/unit/math/rev/functor/reduce_sum2_test.cpp

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 8138f1219d6..c02f8833cd4 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -133,7 +133,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     inline double* accumulate_adjoints(double* x) { return x; }
 
 
-    void operator()(const tbb::blocked_range<size_t>& r) try {
+    inline void operator()(const tbb::blocked_range<size_t>& r) try {
       if (r.empty())
         return;
 
@@ -187,7 +187,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   };
 
   template <typename... Pargs>
-  size_t count_var_impl(size_t count, const std::vector<var>& x,
+  inline size_t count_var_impl(size_t count, const std::vector<var>& x,
                         Pargs&&... args) const {
     return count_var_impl(count + x.size(), std::forward<Pargs>(args)...);
   }
@@ -195,7 +195,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   template <typename T, require_std_vector_st<is_var, T>* = nullptr,
             require_std_vector_vt<is_container, T>* = nullptr,
             typename... Pargs>
-  size_t count_var_impl(size_t count, T&& x, Pargs&&... args) const {
+  inline size_t count_var_impl(size_t count, T&& x, Pargs&&... args) const {
     for (size_t i = 0; i < x.size(); i++) {
       count = count_var_impl(count, x[i]);
     }
@@ -204,23 +204,23 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
 
   template <typename Mat, require_eigen_vt<is_var, Mat>* = nullptr,
             typename... Pargs>
-  size_t count_var_impl(size_t count, Mat&& x, Pargs&&... args) const {
+  inline size_t count_var_impl(size_t count, Mat&& x, Pargs&&... args) const {
     return count_var_impl(count + x.size(), std::forward<Pargs>(args)...);
   }
 
   template <typename... Pargs>
-  size_t count_var_impl(size_t count, const var& x, Pargs&&... args) const {
+  inline size_t count_var_impl(size_t count, const var& x, Pargs&&... args) const {
     return count_var_impl(count + 1, std::forward<Pargs>(args)...);
   }
 
   template <typename Arith,
             require_arithmetic_t<scalar_type_t<Arith>>* = nullptr,
             typename... Pargs>
-  size_t count_var_impl(size_t count, Arith& x, Pargs&&... args) const {
+  inline size_t count_var_impl(size_t count, Arith& x, Pargs&&... args) const {
     return count_var_impl(count, std::forward<Pargs>(args)...);
   }
 
-  size_t count_var_impl(size_t count) const { return count; }
+  inline size_t count_var_impl(size_t count) const { return count; }
 
   /**
    * Count the number of scalars of type T in the input argument list
@@ -229,19 +229,19 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
    * @return Number of scalars of type T in input
    */
   template <typename... Pargs>
-  size_t count_var(Pargs&&... args) const {
+  inline size_t count_var(Pargs&&... args) const {
     return count_var_impl(0, std::forward<Pargs>(args)...);
   }
 
   template <typename... Pargs>
-  vari** save_varis(vari** dest, const var& x, Pargs&&... args) const {
+  inline vari** save_varis(vari** dest, const var& x, Pargs&&... args) const {
     *dest = x.vi_;
     return save_varis(dest + 1, std::forward<Pargs>(args)...);
   }
 
   template <typename VarVec, require_std_vector_vt<is_var, VarVec>* = nullptr,
             typename... Pargs>
-  vari** save_varis(vari** dest, VarVec&& x, Pargs&&... args) const {
+  inline vari** save_varis(vari** dest, VarVec&& x, Pargs&&... args) const {
     using write_map = Eigen::Map<Eigen::Matrix<vari*, -1, 1>>;
     using read_map = Eigen::Map<const Eigen::Matrix<var, -1, 1>>;
     write_map(dest, x.size(), 1) = read_map(x.data(), x.size(), 1).vi();
@@ -252,7 +252,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
             require_std_vector_st<is_var, VecContainer>* = nullptr,
             require_std_vector_vt<is_container, VecContainer>* = nullptr,
             typename... Pargs>
-  vari** save_varis(vari** dest, VecContainer&& x, Pargs&&... args) const {
+  inline vari** save_varis(vari** dest, VecContainer&& x, Pargs&&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest = save_varis(dest, x[i]);
     }
@@ -261,7 +261,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
 
   template <typename Mat, require_eigen_vt<is_var, Mat>* = nullptr,
             typename... Pargs>
-  vari** save_varis(vari** dest, Mat&& x, Pargs&&... args) const {
+  inline vari** save_varis(vari** dest, Mat&& x, Pargs&&... args) const {
     using write_map = Eigen::Map<Eigen::Matrix<vari*,
      std::decay_t<Mat>::RowsAtCompileTime,
      std::decay_t<Mat>::ColsAtCompileTime>>;
@@ -271,14 +271,14 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
 
   template <typename R, require_arithmetic_t<scalar_type_t<R>>* = nullptr,
             typename... Pargs>
-  vari** save_varis(vari** dest, R&& x, Pargs&&... args) const {
+  inline vari** save_varis(vari** dest, R&& x, Pargs&&... args) const {
     return save_varis(dest, std::forward<Pargs>(args)...);
   }
 
-  vari** save_varis(vari** dest) const { return dest; }
+  inline vari** save_varis(vari** dest) const { return dest; }
 
   template <typename VecT, typename... ArgsT>
-  var operator()(VecT&& vmapped, std::size_t grainsize, std::ostream* msgs,
+  inline var operator()(VecT&& vmapped, std::size_t grainsize, std::ostream* msgs,
                  ArgsT&&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
diff --git a/test/unit/math/rev/functor/reduce_sum2_test.cpp b/test/unit/math/rev/functor/reduce_sum2_test.cpp
deleted file mode 100644
index 14b0b82b6d9..00000000000
--- a/test/unit/math/rev/functor/reduce_sum2_test.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-#include <stan/math/prim/core.hpp>
-#include <stan/math.hpp>
-#include <gtest/gtest.h>
-#include <algorithm>
-#include <sstream>
-#include <tuple>
-#include <vector>
-
-std::ostream* msgs = nullptr;
-
-template <typename T>
-struct count_lpdf {
-  count_lpdf() {}
-  template <typename Vec>
-  inline auto operator()(std::size_t start, std::size_t end,
-                      Vec&& sub_slice, std::ostream* msgs,
-                      const T& lambda,
-                      int N) const {
-    using stan::math::var;
-
-    var sum = 0.0;
-    for(int j = start; j < end; j++) {
-      var lambda_mult = sub_slice[j - start] * lambda;
-      for(int i = 0; i < N; i++) {
-        sum += lambda_mult;
-        lambda_mult *= lambda;
-      }
-    }
-
-    return sum;
-  }
-};
-
-TEST(v3_reduce_sum_benchmarks, reduce_sum_small) {
-  using stan::math::var;
-
-  stan::math::init_threadpool_tbb();
-
-  std::vector<int> datasizes = { 1024, 4096, 16384 };
-  std::vector<size_t> grainsizes = { 8, 16, 32, 64, 128, 256 };
-  std::vector<int> worksizes = { 8, 16, 32, 64, 128, 256 };
-
-  std::cout << "which_parallel, datasize, grainsize, worksize, time" << std::endl;
-  for(auto datasize : datasizes) {
-      for(auto worksize : worksizes) {
-        for(auto grainsize : grainsizes) {
-          std::vector<int> data(datasize, 1);
-
-          var lambda_v = 0.5;
-
-          double begin_norm_time = omp_get_wtime();
-          var poisson_lpdf2 = 0.0;
-          for(int i = 0; i < 100; i++) {
-            poisson_lpdf2 += count_lpdf<var>()(0, data.size(), data, msgs, lambda_v, worksize);
-          }
-          double end_norm_time = omp_get_wtime();
-          std::cout << "normie, " << datasize << ", " << grainsize <<
-            ", " << worksize << ", " << end_norm_time - begin_norm_time << std::endl;
-
-          double begin_par_time = omp_get_wtime();
-          var poisson_lpdf = 0.0;
-          for(int i = 0; i < 100; i++) {
-            poisson_lpdf += stan::math::reduce_sum<count_lpdf<var>>(data, grainsize, msgs, lambda_v, worksize);
-          }
-          double end_par_time = omp_get_wtime();
-          std::cout << "reduce_sum, " << datasize << ", " << grainsize <<
-            ", " << worksize << ", " << end_par_time - begin_par_time << std::endl;
-          stan::math::recover_memory();
-        }
-    }
-  }
-
-  stan::math::recover_memory();
-}

From 89d0781f0859721ad2623ee672069fc1e2e8038d Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Sun, 8 Mar 2020 15:55:14 -0400
Subject: [PATCH 088/189] Added signature that for exposing variadic arguments
 to higher level

---
 stan/math/rev/functor.hpp                     |   1 +
 stan/math/rev/functor/coupled_ode_system.hpp  |   6 +-
 stan/math/rev/functor/cvodes_integrator.hpp   |   8 +-
 stan/math/rev/functor/ode_bdf.hpp             |  32 ++++
 .../math/rev/functor/ode_bdf_prim_test.cpp    | 155 ++++++++++++++++++
 5 files changed, 197 insertions(+), 5 deletions(-)
 create mode 100644 stan/math/rev/functor/ode_bdf.hpp
 create mode 100644 test/unit/math/rev/functor/ode_bdf_prim_test.cpp

diff --git a/stan/math/rev/functor.hpp b/stan/math/rev/functor.hpp
index 3ce06abf721..d1f31aef725 100644
--- a/stan/math/rev/functor.hpp
+++ b/stan/math/rev/functor.hpp
@@ -14,6 +14,7 @@
 #include <stan/math/rev/functor/integrate_dae.hpp>
 #include <stan/math/rev/functor/integrate_ode_adams.hpp>
 #include <stan/math/rev/functor/integrate_ode_bdf.hpp>
+#include <stan/math/rev/functor/ode_bdf.hpp>
 #include <stan/math/rev/functor/jacobian.hpp>
 #include <stan/math/rev/functor/kinsol_data.hpp>
 #include <stan/math/rev/functor/kinsol_solve.hpp>
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index c4817a2d382..61ba16d8609 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -119,14 +119,14 @@ struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
 
       const vector<var> y_vars(z.begin(), z.begin() + N_);
       auto local_args_tuple = apply(
-          [&](const Args&... args) {
+          [&](auto&&... args) {
             return std::tuple<decltype(internal::deep_copy(args))...>(
                 internal::deep_copy(args)...);
           },
           args_tuple_);
 
       vector<var> dy_dt_vars = apply(
-          [&](const Args&... args) { return f_(t, y_vars, args..., msgs_); },
+          [&](auto&&... args) { return f_(t, y_vars, args..., msgs_); },
           local_args_tuple);
 
       check_size_match("coupled_ode_system", "dz_dt", dy_dt_vars.size(),
@@ -151,7 +151,7 @@ struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
 
         Eigen::VectorXd args_adjoints = Eigen::VectorXd::Zero(args_vars_);
         apply(
-            [&](const Args&... args) {
+            [&](auto&&... args) {
               internal::accumulate_adjoints(args_adjoints.data(), args...);
             },
             local_args_tuple);
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 3019e213139..cf32c70c836 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -170,9 +170,13 @@ class cvodes_integrator {
   inline void jacobian_states(double t, const double y[], SUNMatrix J) const {
     start_nested();
     const std::vector<var> y_vec_var(y, y + N_);
-    auto ode_jacobian = apply([&](auto&&... args) {
-	return coupled_ode_system<var, double, double, F, decltype(value_of(args))...>(f_, y_vec_var, value_of(args)..., msgs_);
+    // TODO: This should only be done once on construction
+    auto double_args_tuple = apply([&](auto&&... args) {
+	return std::make_tuple(value_of(args)...);
       }, args_tuple_);
+    auto ode_jacobian = apply([&](auto&&... args) {
+	return coupled_ode_system<var, double, double, F, decltype(args)...>(f_, y_vec_var, args..., msgs_);
+      }, double_args_tuple);
     std::vector<double>&& jacobian_y = std::vector<double>(ode_jacobian.size());
     ode_jacobian(ode_jacobian.initial_state(), jacobian_y, t);
     std::move(jacobian_y.begin() + N_, jacobian_y.end(), SM_DATA_D(J));
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
new file mode 100644
index 00000000000..2e2cac6060f
--- /dev/null
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -0,0 +1,32 @@
+#ifndef STAN_MATH_REV_FUNCTOR_ODE_BDF_HPP
+#define STAN_MATH_REV_FUNCTOR_ODE_BDF_HPP
+
+#include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/functor/cvodes_integrator.hpp>
+#include <ostream>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+template <typename F, typename T_initial, typename T_t0, typename T_ts, typename... T_Args>
+std::vector<std::vector<typename stan::return_type<T_initial, T_t0, T_ts, T_Args...>::type>>
+ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
+	const std::vector<T_ts>& ts,
+	double relative_tolerance,
+	double absolute_tolerance,
+	long int max_num_steps,
+	std::ostream* msgs,
+	const T_Args&... args) {  // NOLINT(runtime/int)
+  stan::math::cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...>
+    integrator(f, y0, t0, ts,
+	       args...,
+	       msgs,
+	       relative_tolerance, absolute_tolerance,
+	       max_num_steps);
+  return integrator.integrate();
+}
+
+}  // namespace math
+}  // namespace stan
+#endif
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
new file mode 100644
index 00000000000..48b4d934d27
--- /dev/null
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -0,0 +1,155 @@
+#include <stan/math/rev.hpp>
+#include <boost/numeric/odeint.hpp>
+#include <gtest/gtest.h>
+#include <test/unit/util.hpp>
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <limits>
+#include <string>
+
+template <typename T>
+T sum_(T arg) {
+  return arg;
+}
+
+template <typename T, int RowType, int ColType>
+auto sum_(const Eigen::Matrix<T, RowType, ColType>& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename T>
+auto sum_(const std::vector<T>& arg) {
+  stan::scalar_type_t<T> sum = 0;
+  for (size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
+  }
+  return sum;
+}
+
+struct Cos1Arg {
+  template <typename T0, typename T1, typename T2>
+  inline std::vector<typename stan::return_type<T1, T2>::type>
+  operator()(const T0& t, const std::vector<T1>& y,
+	     const T2& a, std::ostream* msgs) const {
+
+    return { stan::math::cos(sum_(a) * t) };
+  }
+};
+
+struct Cos2Arg {
+  template <typename T0, typename T1, typename T2, typename T3>
+  inline std::vector<typename stan::return_type<T1, T2, T3>::type>
+  operator()(const T0& t, const std::vector<T1>& y,
+	     const T2& a, const T3& b, std::ostream* msgs) const {
+    
+    return { stan::math::cos((sum_(a) + sum_(b)) * t) };
+  }
+};
+
+TEST(StanMathOde_ode_bdf, scalar_arg) {
+  using stan::math::var;
+  
+  std::vector<double> y0 = { 0.0 };
+  double t0 = 0.0;
+  std::vector<double> ts = { 1.1 };
+
+  var a = 1.5;
+  
+  var output = stan::math::ode_bdf(Cos1Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_bdf, std_vector_arg) {
+  using stan::math::var;
+  
+  std::vector<double> y0 = { 0.0 };
+  double t0 = 0.0;
+  std::vector<double> ts = { 1.1 };
+
+  std::vector<var> a = { 1.5 };
+  
+  var output = stan::math::ode_bdf(Cos1Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a[0].adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_bdf, vector_arg) {
+  using stan::math::var;
+  
+  std::vector<double> y0 = { 0.0 };
+  double t0 = 0.0;
+  std::vector<double> ts = { 1.1 };
+
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
+  a << 1.5;
+  
+  var output = stan::math::ode_bdf(Cos1Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_bdf, row_vector_arg) {
+  using stan::math::var;
+  
+  std::vector<double> y0 = { 0.0 };
+  double t0 = 0.0;
+  std::vector<double> ts = { 1.1 };
+
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
+  a << 1.5;
+  
+  var output = stan::math::ode_bdf(Cos1Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_bdf, matrix_arg) {
+  using stan::math::var;
+  
+  std::vector<double> y0 = { 0.0 };
+  double t0 = 0.0;
+  std::vector<double> ts = { 1.1 };
+
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
+  a << 1.5;
+  
+  var output = stan::math::ode_bdf(Cos1Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0, 0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_bdf, scalar_std_vector_args) {
+  using stan::math::var;
+  
+  std::vector<double> y0 = { 0.0 };
+  double t0 = 0.0;
+  std::vector<double> ts = { 1.1 };
+
+  var a0 = 0.0;
+  std::vector<var> a1 = { 1.5 };
+  
+  var output = stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr,
+				   a0, a1)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
+}

From e8b02947ef36ea229fd2c7783062f72d597c0426 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Sun, 8 Mar 2020 22:16:00 -0400
Subject: [PATCH 089/189] Made some changes so ode rhs functions with variadic
 arguments work with ode_bdf

---
 stan/math/rev/functor/coupled_ode_system.hpp  |  4 ++--
 stan/math/rev/functor/cvodes_integrator.hpp   |  2 +-
 .../math/rev/functor/ode_bdf_prim_test.cpp    | 21 ++++++++++---------
 3 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index 61ba16d8609..b2b904b7c86 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -126,7 +126,7 @@ struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
           args_tuple_);
 
       vector<var> dy_dt_vars = apply(
-          [&](auto&&... args) { return f_(t, y_vars, args..., msgs_); },
+				     [&](auto&&... args) { return f_.template operator()<double, var, decltype(args)...>(t, y_vars, args..., msgs_); },
           local_args_tuple);
 
       check_size_match("coupled_ode_system", "dz_dt", dy_dt_vars.size(),
@@ -188,7 +188,7 @@ struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
 	  return f_(t, y_vars, args..., msgs_);
 	  }, local_args_tuple);*/
       dy_dt = apply([&](auto&&... args) {
-	  return f_(value_of(t), y_dbl, value_of(args)..., msgs_);
+	  return f_.template operator()<double, double, decltype(value_of(args))...>(value_of(t), y_dbl, value_of(args)..., msgs_);
 	}, args_tuple_);
       check_size_match("coupled_ode_observer", "dy_dt", dy_dt.size(), "states", N_);
     }
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index cf32c70c836..5881da2837c 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -153,7 +153,7 @@ class cvodes_integrator {
   inline void rhs(double t, const double y[], double dy_dt[]) const {
     const std::vector<double> y_vec(y, y + N_);
     std::vector<double> dy_dt_vec = apply([&](auto&&... args) {
-	return f_(t, y_vec, value_of(args)..., msgs_);
+	return f_.template operator()<double, double, decltype(value_of(args))...>(t, y_vec, value_of(args)..., msgs_);
       }, args_tuple_);
     check_size_match("cvodes_ode_data", "dz_dt", dy_dt_vec.size(), "states",
                      N_);
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index 48b4d934d27..b380f79037b 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -27,13 +27,13 @@ auto sum_(const std::vector<T>& arg) {
   return sum;
 }
 
-struct Cos1Arg {
-  template <typename T0, typename T1, typename T2>
-  inline std::vector<typename stan::return_type<T1, T2>::type>
+struct CosArg1 {
+  template <typename T0, typename T1, typename... T_Args>
+  inline std::vector<typename stan::return_type<T1, T_Args...>::type>
   operator()(const T0& t, const std::vector<T1>& y,
-	     const T2& a, std::ostream* msgs) const {
+	     const T_Args&... a, std::ostream* msgs) const {
 
-    return { stan::math::cos(sum_(a) * t) };
+    return { stan::math::cos(sum_(std::get<0>(std::make_tuple(a...))) * t) };
   }
 };
 
@@ -56,7 +56,7 @@ TEST(StanMathOde_ode_bdf, scalar_arg) {
 
   var a = 1.5;
   
-  var output = stan::math::ode_bdf(Cos1Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -73,7 +73,7 @@ TEST(StanMathOde_ode_bdf, std_vector_arg) {
 
   std::vector<var> a = { 1.5 };
   
-  var output = stan::math::ode_bdf(Cos1Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -91,7 +91,7 @@ TEST(StanMathOde_ode_bdf, vector_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
   a << 1.5;
   
-  var output = stan::math::ode_bdf(Cos1Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -109,7 +109,7 @@ TEST(StanMathOde_ode_bdf, row_vector_arg) {
   Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
   a << 1.5;
   
-  var output = stan::math::ode_bdf(Cos1Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -127,7 +127,7 @@ TEST(StanMathOde_ode_bdf, matrix_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
   a << 1.5;
   
-  var output = stan::math::ode_bdf(Cos1Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -153,3 +153,4 @@ TEST(StanMathOde_ode_bdf, scalar_std_vector_args) {
   EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
   EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
 }
+

From a017619563c12fc53e79066c6a621464d0d6b4e8 Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Mon, 9 Mar 2020 17:01:36 -0400
Subject: [PATCH 090/189] Add docs for templates in reduce_sum

---
 stan/math/prim/functor/reduce_sum.hpp |  88 ++++++---
 stan/math/rev/functor/reduce_sum.hpp  | 272 +++++++++++++++++++++-----
 2 files changed, 284 insertions(+), 76 deletions(-)

diff --git a/stan/math/prim/functor/reduce_sum.hpp b/stan/math/prim/functor/reduce_sum.hpp
index 81177a6cf53..6a4b3f791eb 100644
--- a/stan/math/prim/functor/reduce_sum.hpp
+++ b/stan/math/prim/functor/reduce_sum.hpp
@@ -20,35 +20,63 @@ namespace math {
 
 namespace internal {
 
+/**
+ * Base definition of implimentation called by reduce `reduce_sum`.
+ * @tparam ReduceFunction An type with a valid `operator()`
+ * @tparam ReturnType The return type of the call to
+ * `ReduceFunction::operator()`
+ * @tparam Vec type of the first input argument with an `operator[]`
+ * @tparam Args Parameter pack holding the types of the object send to
+ * `ReduceFunction::operator()`
+ */
 template <typename ReduceFunction, typename Enable, typename ReturnType,
           typename Vec, typename... Args>
 struct reduce_sum_impl {
-  return_type_t<Vec, Args...> operator()(const Vec& vmapped,
-                                         std::size_t grainsize,
-                                         std::ostream* msgs,
-                                         const Args&... args) const {
+  template <typename OpVec, typename... OpArgs,
+  typename = require_same_t<Vec, OpVec>,
+  typename = require_all_t<std::is_same<Args, OpArgs>...>>
+  return_type_t<OpVec, OpArgs...> operator()(OpVec&& vmapped, std::size_t grainsize, std::ostream* msgs,
+    OpArgs&&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
-    if (num_jobs == 0)
-      return 0.0;
+    if (num_jobs == 0) {
+      return 0.0;      
+    }
 
-    return ReduceFunction()(0, vmapped.size() - 1, vmapped, msgs, args...);
+    return ReduceFunction()(0, vmapped.size() - 1, std::forward<OpVec>(vmapped),
+      msgs, std::forward<OpArgs>(args)...);
   }
 };
 
+/**
+ * Arithmetic definition of implimentation called by reduce `reduce_sum`.
+ * @tparam ReduceFunction An type with a valid `operator()`
+ * @tparam ReturnType The return type of the call to
+ * `ReduceFunction::operator()`
+ * @tparam Vec type of the first input argument with an `operator[]`
+ * @tparam Args Parameter pack holding the types of the object send to
+ * `ReduceFunction::operator()`
+ */
 template <typename ReduceFunction, typename ReturnType, typename Vec,
           typename... Args>
 struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
                        ReturnType, Vec, Args...> {
+  /**
+   * Internal object used in `tbb::parallel_reduce`
+   * @note see link [here](https://tinyurl.com/vp7xw2t) for requirements.
+   */
   struct recursive_reducer {
     Vec vmapped_;
     std::ostream* msgs_;
     std::tuple<Args...> args_tuple_;
     return_type_t<Vec, Args...> sum_{0.0};
-    template <typename VecT, typename... ArgsT>
-    recursive_reducer(VecT&& vmapped, std::ostream* msgs, ArgsT&&... args)
-        : vmapped_(std::forward<VecT>(vmapped)), msgs_(msgs),
-          args_tuple_(std::forward<ArgsT>(args)...) {}
+
+    template <typename OpVec, typename... OpArgs,
+    typename = require_same_t<Vec, OpVec>,
+    typename = require_all_t<std::is_same<Args, OpArgs>...>>
+    recursive_reducer(OpVec&& vmapped, std::ostream* msgs, OpArgs&&... args)
+        : vmapped_(std::forward<OpVec>(vmapped)), msgs_(msgs),
+          args_tuple_(std::forward<OpArgs>(args)...) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
         : vmapped_(other.vmapped_),
@@ -60,9 +88,9 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
         return;
       }
 
-      auto start = vmapped_.begin();
+      auto start = this->vmapped_.begin();
       std::advance(start, r.begin());
-      auto end = vmapped_.begin();
+      auto end = this->vmapped_.begin();
       std::advance(end, r.end());
 
       const std::decay_t<Vec> sub_slice(start, end);
@@ -72,24 +100,30 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
             return ReduceFunction()(r.begin(), r.end() - 1, sub_slice, msgs_,
                                     args...);
           },
-          args_tuple_);
+          this->args_tuple_);
     }
-
-    void join(const recursive_reducer& child) { sum_ += child.sum_; }
+    /**
+     * Join the sum of the reducers
+     * @param child A sub-reducer that is aggregated to make the final reduced
+     * value.
+     * @note side effect of updating `recursive_reducer->sum_`
+     */
+    void join(const recursive_reducer& child) { this->sum_ += child.sum_; }
   };
-  template <typename VecT, typename... ArgsT>
-  return_type_t<Vec, Args...> operator()(VecT&& vmapped,
+
+  template <typename OpVec, typename... OpArgs,
+  typename = require_same_t<Vec, OpVec>,
+  typename = require_all_t<std::is_same<Args, OpArgs>...>>
+  return_type_t<OpVec, OpArgs...> operator()(OpVec&& vmapped,
                                          std::size_t grainsize,
                                          std::ostream* msgs,
-                                         ArgsT&&... args) const {
+                                         OpArgs&&... args) const {
     const std::size_t num_jobs = vmapped.size();
-
     if (num_jobs == 0) {
       return 0.0;
     }
-
-    recursive_reducer worker(std::forward<VecT>(vmapped), msgs,
-     std::forward<ArgsT>(args)...);
+    recursive_reducer worker(std::forward<OpVec>(vmapped), msgs,
+     std::forward<OpArgs>(args)...);
 
 #ifdef STAN_DETERMINISTIC
     tbb::static_partitioner partitioner;
@@ -108,11 +142,15 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
 }  // namespace internal
 
 /*
- * Note that the ReduceFunction is only passed in as type to prohibit
+ * Performs a map and reduce sum over a function.
+ * @tparam ReduceFunction An type with a valid `operator()`
+ * @tparam Vec type of the first input argument with an `operator[]`
+ * @tparam Args Parameter pack holding the types of the object send to
+ * @note The ReduceFunction is only passed in as type to prohibit
  * that any internal state of the functor is causing trouble. Thus,
  * the functor must be default constructible without any arguments.
  */
-template <typename ReduceFunction, typename Vec, require_vector_like_t<Vec>...,
+template <typename ReduceFunction, typename Vec, typename = require_vector_like_t<Vec>,
           typename... Args>
 auto reduce_sum(Vec&& vmapped, std::size_t grainsize, std::ostream* msgs,
                 Args&&... args) {
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index c02f8833cd4..19af0ed820f 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -18,21 +18,32 @@ namespace stan {
 namespace math {
 namespace internal {
 
+/**
+ * Var specialization of implimentation called by reduce `reduce_sum`.
+ * @tparam ReduceFunction An type with a valid `operator()`
+ * @tparam ReturnType The return type of the call to
+ * `ReduceFunction::operator()`
+ * @tparam Vec type of the first input argument with an `operator[]`
+ * @tparam Args Parameter pack holding the types of the object send to
+ * `ReduceFunction::operator()`
+ */
 template <typename ReduceFunction, typename ReturnType, typename Vec,
           typename... Args>
 struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
                        Vec, Args...> {
-
-
+ /**
+  * Internal object used in `tbb::parallel_reduce`
+  * @note see link [here](https://tinyurl.com/vp7xw2t) for requirements.
+  */
   struct recursive_reducer {
-    size_t num_shared_terms_;
-    double* sliced_partials_;
+    size_t num_shared_terms_; // Number of terms shared across threads
+    double* sliced_partials_; // Points to adjoints of the partial calculations
     Vec vmapped_;
     std::ostream* msgs_;
     std::tuple<Args...> args_tuple_;
-
     double sum_{0.0};
     Eigen::VectorXd args_adjoints_{0};
+
     template <typename VecT, typename... ArgsT>
     recursive_reducer(size_t num_shared_terms, double* sliced_partials,
                       VecT&& vmapped, std::ostream* msgs,
@@ -50,15 +61,30 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
           msgs_(other.msgs_),
           args_tuple_(other.args_tuple_) {}
 
-    template <typename T, typename = require_arithmetic_t<scalar_type_t<T>>>
-    inline auto deep_copy(T arg) {
-      return arg;
+    /**
+     * Specialization of deep copy that returns references for arithmetic types.
+     * @tparam Arith an arithmetic type.
+     * @param arg For lvalue references this will be passed by reference.
+     *  Otherwise it will be moved.
+     */
+    template <typename Arith, typename = require_arithmetic_t<scalar_type_t<Arith>>>
+    inline decltype(auto) deep_copy(Arith&& arg) {
+      return std::forward<Arith>(arg);
     }
 
+    /**
+     * Specialization to copy a single var
+     * @param arg a var.
+     */
     inline auto deep_copy(const var& arg) {
       return var(new vari(arg.val(), false));
     }
 
+    /**
+     * Specialization to copy a standard vector of vars.
+     * @tparam VarVec A standard vector holding vars.
+     * @param arg A standard vector holding vars.
+     */
     template <typename VarVec, require_std_vector_vt<is_var, VarVec>* = nullptr>
     inline auto deep_copy(VarVec&& arg) {
       std::vector<var> copy_vec(arg.size());
@@ -68,6 +94,11 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
       return copy_vec;
     }
 
+    /**
+     * Specialization to copy a standard vector holding containers.
+     * @tparam VarVec A standard vector holding containers of vars.
+     * @param arg A standard vector holding containers of vars.
+     */
     template <typename VarVec, require_std_vector_st<is_var, VarVec>* = nullptr,
               require_std_vector_vt<is_container, VarVec>* = nullptr>
     inline auto deep_copy(VarVec&& arg) {
@@ -78,13 +109,25 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
       return copy_vec;
     }
 
-    template <typename Mat, require_eigen_vt<is_var, Mat>* = nullptr>
-    inline auto deep_copy(Mat&& arg) {
+    /**
+     * Specialization to copy an `Eigen` containers of vars.
+     * @tparam EigT A type derived from `EigenBase` containing vars.
+     * @param arg A container hollding var types.
+     */
+    template <typename EigT, require_eigen_vt<is_var, EigT>* = nullptr>
+    inline auto deep_copy(EigT&& arg) {
       return arg.unaryExpr([](auto&& x) {
          return var(new vari(x.val(), false));
        }).eval();;
     }
 
+    /**
+     * Accumulates adjoints for a single var within the reduce.
+     * @tparam Pargs types of further arguments to accumulate over.
+     * @param dest points to values holding adjoint accumulate.
+     * @param x A var to accumulate the adjoint of.
+     * @param args Further args to accumulate over.
+     */
     template <typename... Pargs>
     inline double* accumulate_adjoints(double* dest, const var& x,
                                        Pargs&&... args) {
@@ -92,6 +135,14 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
       return accumulate_adjoints(dest + 1, std::forward<Pargs>(args)...);
     }
 
+    /**
+     * Accumulates adjoints for a standard vector of vars within the reduce.
+     * @tparam VarVec the type of a standard container holding vars.
+     * @tparam Pargs types of further arguments to accumulate over.
+     * @param dest points to values holding adjoint accumulate.
+     * @param x A vector of vars to accumulate the adjoint of.
+     * @param args Further args to accumulate over.
+     */
     template <typename VarVec, require_std_vector_vt<is_var, VarVec>* = nullptr, typename... Pargs>
     inline double* accumulate_adjoints(double* dest, VarVec&& x,
                                        Pargs&&... args) {
@@ -102,6 +153,14 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
       return accumulate_adjoints(dest, std::forward<Pargs>(args)...);
     }
 
+    /**
+     * Accumulates adjoints for a standard vector of containers within the reduce.
+     * @tparam VecContainer the type of a standard container holding var containers.
+     * @tparam Pargs types of further arguments to accumulate over.
+     * @param dest points to values holding adjoint accumulate.
+     * @param x A vector of var containers to accumulate the adjoint of.
+     * @param args Further args to accumulate over.
+     */
     template <typename VecContainer,
         require_std_vector_st<is_var, VecContainer>* = nullptr,
         require_std_vector_vt<is_container, VecContainer>* = nullptr,
@@ -114,14 +173,31 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
       return accumulate_adjoints(dest, std::forward<Pargs>(args)...);
     }
 
-    template <typename Mat, require_eigen_vt<is_var, Mat>* = nullptr,
+    /**
+     * Accumulates adjoints for an eigen container within the reduce.
+     * @tparam EigT Type derived from `EigenBase` containing vars.
+     * @tparam Pargs types of further arguments to accumulate over.
+     * @param dest points to values holding adjoint accumulate.
+     * @param x An eigen type holding vars to accumulate over.
+     * @param args Further args to accumulate over.
+     */
+    template <typename EigT, require_eigen_vt<is_var, EigT>* = nullptr,
               typename... Pargs>
-    inline double* accumulate_adjoints(double* dest, const Mat& x,
+    inline double* accumulate_adjoints(double* dest, EigT&& x,
                                        Pargs&&... args) {
       Eigen::Map<Eigen::MatrixXd>(dest, x.rows(), x.cols()) += x.adj();
       return accumulate_adjoints(dest + x.size(), std::forward<Pargs>(args)...);
     }
 
+    /**
+     * Specialization that is a no-op for Arithmetic types.
+     * @tparam Arith A type satisfying `std::is_arithmetic`.
+     * @tparam Pargs types of further arguments to accumulate over.
+     * @param dest points to values holding adjoint accumulate.
+     * @param x An object that is either arithmetic or a container of Arithmetic
+     *  types.
+     * @param args Further args to accumulate over.
+     */
     template <typename Arith,
               require_arithmetic_t<scalar_type_t<Arith>>* = nullptr,
               typename... Pargs>
@@ -132,16 +208,19 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
 
     inline double* accumulate_adjoints(double* x) { return x; }
 
-
-    inline void operator()(const tbb::blocked_range<size_t>& r) try {
-      if (r.empty())
+    /**
+     * Within thread reduction.
+     */
+    inline void operator()(const tbb::blocked_range<size_t>& r) {
+      if (r.empty()) {
         return;
+      }
 
       if (args_adjoints_.size() == 0) {
         args_adjoints_ = Eigen::VectorXd::Zero(this->num_shared_terms_);
       }
 
-      start_nested();
+      const nested_rev_autodiff begin_nest;
       // create a deep copy of all var's so that these are not
       // linked to any outer AD tree
       std::decay_t<Vec> local_sub_slice;
@@ -170,49 +249,90 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
              std::forward<decltype(args)>(args)...);
           },
           std::move(args_tuple_local_copy));
-      recover_memory_nested();
-    } catch (const std::exception& e) {
-      recover_memory_nested();
-      throw;
     }
 
+    /**
+     * Join the sum of the reducers
+     * @param child A sub-reducer that is aggregated to make the final reduced
+     * value.
+     * @note side effect of updating `sum_` and
+     *  `args_adjoints_`
+     */
     void join(const recursive_reducer& rhs) {
-      sum_ += rhs.sum_;
-      if (args_adjoints_.size() != 0 && rhs.args_adjoints_.size() != 0) {
-        args_adjoints_ += rhs.args_adjoints_;
-      } else if (args_adjoints_.size() == 0 && rhs.args_adjoints_.size() != 0) {
-        args_adjoints_ = rhs.args_adjoints_;
+      this->sum_ += rhs.sum_;
+      if (this->args_adjoints_.size() != 0 && rhs.args_adjoints_.size() != 0) {
+        this->args_adjoints_ += rhs.args_adjoints_;
+      } else if (this->args_adjoints_.size() == 0 && rhs.args_adjoints_.size() != 0) {
+        this->args_adjoints_ = rhs.args_adjoints_;
       }
     }
   };
 
-  template <typename... Pargs>
-  inline size_t count_var_impl(size_t count, const std::vector<var>& x,
+  /**
+   * Count the number of vars in an vector.
+   * @tparam Vec type of standard container holding vars.
+   * @tparam Pargs Types to be forwarded to recursive call of `count_var_impl`.
+   * @param[in] count The current count of the number of vars.
+   * @param[in] x A vector holding vars.
+   * @param[in] args objects to be forwarded to recursive call of `count_var_impl`
+   */
+  template <typename VecVar, require_std_vector_vt<is_var, VecVar>* = nullptr, typename... Pargs>
+  inline size_t count_var_impl(size_t count, VecVar&& x,
                         Pargs&&... args) const {
     return count_var_impl(count + x.size(), std::forward<Pargs>(args)...);
   }
 
-  template <typename T, require_std_vector_st<is_var, T>* = nullptr,
-            require_std_vector_vt<is_container, T>* = nullptr,
+  /**
+   * Count the number of vars in an vector holding containers.
+   * @tparam A standard vector holding containers of vars.
+   * @tparam Pargs Types to be forwarded to recursive call of `count_var_impl`.
+   * @param[in] count The current count of the number of vars.
+   * @param[in] x A vector holding containers of vars.
+   * @param[in] args objects to be forwarded to recursive call of `count_var_impl`
+   */
+  template <typename VecContainer, require_std_vector_st<is_var, VecContainer>* = nullptr,
+            require_std_vector_vt<is_container, VecContainer>* = nullptr,
             typename... Pargs>
-  inline size_t count_var_impl(size_t count, T&& x, Pargs&&... args) const {
-    for (size_t i = 0; i < x.size(); i++) {
-      count = count_var_impl(count, x[i]);
+  inline size_t count_var_impl(size_t count, VecContainer&& x, Pargs&&... args) const {
+    for (auto&& x_iter : x) {
+      count = count_var_impl(count, x_iter);
     }
     return count_var_impl(count, std::forward<Pargs>(args)...);
   }
-
-  template <typename Mat, require_eigen_vt<is_var, Mat>* = nullptr,
+  /**
+   * Count the number of vars in an eigen container.
+   * @tparam EigT A type derived from `EigenBase`.
+   * @tparam Pargs Types to be forwarded to recursive call of `count_var_impl`.
+   * @param[in] count The current count of the number of vars.
+   * @param[in] x An Eigen container holding vars.
+   * @param[in] args objects to be forwarded to recursive call of `count_var_impl`
+   */
+  template <typename EigT, require_eigen_vt<is_var, EigT>* = nullptr,
             typename... Pargs>
-  inline size_t count_var_impl(size_t count, Mat&& x, Pargs&&... args) const {
+  inline size_t count_var_impl(size_t count, EigT&& x, Pargs&&... args) const {
     return count_var_impl(count + x.size(), std::forward<Pargs>(args)...);
   }
 
+  /**
+   * Add a var to the count.
+   * @tparam Pargs Types to be forwarded to recursive call of `count_var_impl`.
+   * @param[in] count The current count of the number of vars.
+   * @param[in] x A var.
+   * @param[in] args objects to be forwarded to recursive call of `count_var_impl`
+   */
   template <typename... Pargs>
   inline size_t count_var_impl(size_t count, const var& x, Pargs&&... args) const {
     return count_var_impl(count + 1, std::forward<Pargs>(args)...);
   }
 
+  /**
+   * Specialization that performs skips count for arithmetic types and containers.
+   * @tparam Arith An object that is either arithmetic or holds arithmetic types.
+   * @tparam Pargs Types to be forwarded to recursive call of `count_var_impl`.
+   * @param[in] count The current count of the number of vars.
+   * @param[in] x An arithmetic value or container.
+   * @param[in] args objects to be forwarded to recursive call of `count_var_impl`
+   */
   template <typename Arith,
             require_arithmetic_t<scalar_type_t<Arith>>* = nullptr,
             typename... Pargs>
@@ -220,6 +340,9 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     return count_var_impl(count, std::forward<Pargs>(args)...);
   }
 
+  /**
+   * Specialization to end recursion
+   */
   inline size_t count_var_impl(size_t count) const { return count; }
 
   /**
@@ -233,12 +356,27 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     return count_var_impl(0, std::forward<Pargs>(args)...);
   }
 
+  /**
+   * Store a reference to `vari` used in `reduce_sum`.
+   * @tparam Pargs Types to be forwarded to recursive call of `save_varis`.
+   * @param[in, out] dest Pointer to set of varis.
+   * @param[in] x A `var` whose `vari` will be stores
+   * @param[in] args Further arguments forwarded to recursive call.
+   */
   template <typename... Pargs>
   inline vari** save_varis(vari** dest, const var& x, Pargs&&... args) const {
     *dest = x.vi_;
     return save_varis(dest + 1, std::forward<Pargs>(args)...);
   }
 
+  /**
+   * Store a reference to an std vector's `vari` used in `reduce_sum`.
+   * @tparam VarVec Type of standard vector holding vars.
+   * @tparam Pargs Types to be forwarded to recursive call of `save_varis`.
+   * @param[in, out] dest Pointer to set of varis.
+   * @param[in] x A standard vector whose vari's are stored.
+   * @param[in] args Further arguments forwarded to recursive call.
+   */
   template <typename VarVec, require_std_vector_vt<is_var, VarVec>* = nullptr,
             typename... Pargs>
   inline vari** save_varis(vari** dest, VarVec&& x, Pargs&&... args) const {
@@ -248,6 +386,14 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     return save_varis(dest + x.size(), std::forward<Pargs>(args)...);
   }
 
+  /**
+   * Store a reference to an std vector of containers's `vari` used in `reduce_sum`.
+   * @tparam VecContainer Type of standard vector holding containers of vars.
+   * @tparam Pargs Types to be forwarded to recursive call of `save_varis`.
+   * @param[in, out] dest Pointer to set of varis.
+   * @param[in] x A standard vector whose container's varis are stored.
+   * @param[in] args Further arguments forwarded to recursive call.
+   */
   template <typename VecContainer,
             require_std_vector_st<is_var, VecContainer>* = nullptr,
             require_std_vector_vt<is_container, VecContainer>* = nullptr,
@@ -259,31 +405,54 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     return save_varis(dest, std::forward<Pargs>(args)...);
   }
 
-  template <typename Mat, require_eigen_vt<is_var, Mat>* = nullptr,
+  /**
+   * Store a reference to an Eigen types `vari` used in `reduce_sum`.
+   * @tparam VarVec Type derived from `EigenBase` holding vars.
+   * @tparam Pargs Types to be forwarded to recursive call of `save_varis`.
+   * @param[in, out] dest Pointer to set of varis.
+   * @param[in] x An `EigenBase` whose vari's are stored.
+   * @param[in] args Further arguments forwarded to recursive call.
+   */
+  template <typename EigT, require_eigen_vt<is_var, EigT>* = nullptr,
             typename... Pargs>
-  inline vari** save_varis(vari** dest, Mat&& x, Pargs&&... args) const {
-    using write_map = Eigen::Map<Eigen::Matrix<vari*,
-     std::decay_t<Mat>::RowsAtCompileTime,
-     std::decay_t<Mat>::ColsAtCompileTime>>;
+  inline vari** save_varis(vari** dest, EigT&& x, Pargs&&... args) const {
+    using mat_t = std::decay_t<EigT>;
+    using write_map = Eigen::Map<Eigen::Matrix<vari*, mat_t::RowsAtCompileTime,
+     mat_t::ColsAtCompileTime>>;
     write_map(dest, x.rows(), x.cols()) = x.vi();
     return save_varis(dest + x.size(), std::forward<Pargs>(args)...);
   }
 
-  template <typename R, require_arithmetic_t<scalar_type_t<R>>* = nullptr,
+  /**
+   * Specialization to skip over arithmetic types and containers of arithmetic types.
+   * @tparam Arith either an arithmetic type or container holding arithmetic types.
+   * @tparam Pargs Types to be forwarded to recursive call of `save_varis`.
+   * @param[in, out] dest Pointer to set of varis.
+   * @param[in] x arithmetic or container of arithmetics.
+   * @param[in] args Further arguments forwarded to recursive call.
+   */
+  template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>* = nullptr,
             typename... Pargs>
-  inline vari** save_varis(vari** dest, R&& x, Pargs&&... args) const {
+  inline vari** save_varis(vari** dest, Arith&& x, Pargs&&... args) const {
     return save_varis(dest, std::forward<Pargs>(args)...);
   }
-
+  /**
+   * Ends the recursion by returning the input `vari**`
+   * @param dest a pointer to pointers to varis.
+   * @return the `dest` vari* pointer
+   */
   inline vari** save_varis(vari** dest) const { return dest; }
 
-  template <typename VecT, typename... ArgsT>
-  inline var operator()(VecT&& vmapped, std::size_t grainsize, std::ostream* msgs,
-                 ArgsT&&... args) const {
+  template <typename OpVec, typename... OpArgs,
+  typename = require_same_t<Vec, OpVec>,
+  typename = require_all_t<std::is_same<Args, OpArgs>...>>
+  inline var operator()(OpVec&& vmapped, std::size_t grainsize, std::ostream* msgs,
+                 OpArgs&&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
-    if (num_jobs == 0)
-      return var(0.0);
+    if (num_jobs == 0) {
+      return var(0.0);      
+    }
 
     const std::size_t num_sliced_terms = count_var(vmapped);
     const std::size_t num_shared_terms = count_var(args...);
@@ -293,8 +462,9 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(
         num_sliced_terms + num_shared_terms);
 
-    for (size_t i = 0; i < num_sliced_terms; ++i)
+    for (size_t i = 0; i < num_sliced_terms; ++i) {
       partials[i] = 0.0;
+    }
     recursive_reducer worker(num_shared_terms, partials, vmapped, msgs,
                              args...);
 
@@ -308,8 +478,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
         tbb::blocked_range<std::size_t>(0, num_jobs, grainsize), worker);
 #endif
 
-    save_varis(varis, std::forward<VecT>(vmapped));
-    save_varis(varis + num_sliced_terms, std::forward<ArgsT>(args)...);
+    save_varis(varis, std::forward<OpVec>(vmapped));
+    save_varis(varis + num_sliced_terms, std::forward<OpArgs>(args)...);
 
     for (size_t i = 0; i < num_shared_terms; ++i) {
       partials[num_sliced_terms + i] = worker.args_adjoints_(i);

From 3e36ba840beeef045c23d7d2b5d66f00ec6cac1c Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 9 Mar 2020 17:09:54 -0400
Subject: [PATCH 091/189] [Jenkins] auto-formatting by clang-format version
 5.0.2-svn328729-1~exp1~20180509124008.99 (branches/release_50)

---
 stan/math/prim/functor/reduce_sum.hpp         |  42 +++----
 stan/math/rev/functor/reduce_sum.hpp          | 108 +++++++++++-------
 .../unit/math/mix/functor/reduce_sum_test.cpp |  16 ++-
 .../unit/math/rev/functor/reduce_sum_test.cpp |   5 +-
 4 files changed, 95 insertions(+), 76 deletions(-)

diff --git a/stan/math/prim/functor/reduce_sum.hpp b/stan/math/prim/functor/reduce_sum.hpp
index 6a4b3f791eb..2cb891a8ccf 100644
--- a/stan/math/prim/functor/reduce_sum.hpp
+++ b/stan/math/prim/functor/reduce_sum.hpp
@@ -33,18 +33,20 @@ template <typename ReduceFunction, typename Enable, typename ReturnType,
           typename Vec, typename... Args>
 struct reduce_sum_impl {
   template <typename OpVec, typename... OpArgs,
-  typename = require_same_t<Vec, OpVec>,
-  typename = require_all_t<std::is_same<Args, OpArgs>...>>
-  return_type_t<OpVec, OpArgs...> operator()(OpVec&& vmapped, std::size_t grainsize, std::ostream* msgs,
-    OpArgs&&... args) const {
+            typename = require_same_t<Vec, OpVec>,
+            typename = require_all_t<std::is_same<Args, OpArgs>...>>
+  return_type_t<OpVec, OpArgs...> operator()(OpVec&& vmapped,
+                                             std::size_t grainsize,
+                                             std::ostream* msgs,
+                                             OpArgs&&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
     if (num_jobs == 0) {
-      return 0.0;      
+      return 0.0;
     }
 
     return ReduceFunction()(0, vmapped.size() - 1, std::forward<OpVec>(vmapped),
-      msgs, std::forward<OpArgs>(args)...);
+                            msgs, std::forward<OpArgs>(args)...);
   }
 };
 
@@ -72,10 +74,11 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
     return_type_t<Vec, Args...> sum_{0.0};
 
     template <typename OpVec, typename... OpArgs,
-    typename = require_same_t<Vec, OpVec>,
-    typename = require_all_t<std::is_same<Args, OpArgs>...>>
+              typename = require_same_t<Vec, OpVec>,
+              typename = require_all_t<std::is_same<Args, OpArgs>...>>
     recursive_reducer(OpVec&& vmapped, std::ostream* msgs, OpArgs&&... args)
-        : vmapped_(std::forward<OpVec>(vmapped)), msgs_(msgs),
+        : vmapped_(std::forward<OpVec>(vmapped)),
+          msgs_(msgs),
           args_tuple_(std::forward<OpArgs>(args)...) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
@@ -112,18 +115,18 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
   };
 
   template <typename OpVec, typename... OpArgs,
-  typename = require_same_t<Vec, OpVec>,
-  typename = require_all_t<std::is_same<Args, OpArgs>...>>
+            typename = require_same_t<Vec, OpVec>,
+            typename = require_all_t<std::is_same<Args, OpArgs>...>>
   return_type_t<OpVec, OpArgs...> operator()(OpVec&& vmapped,
-                                         std::size_t grainsize,
-                                         std::ostream* msgs,
-                                         OpArgs&&... args) const {
+                                             std::size_t grainsize,
+                                             std::ostream* msgs,
+                                             OpArgs&&... args) const {
     const std::size_t num_jobs = vmapped.size();
     if (num_jobs == 0) {
       return 0.0;
     }
     recursive_reducer worker(std::forward<OpVec>(vmapped), msgs,
-     std::forward<OpArgs>(args)...);
+                             std::forward<OpArgs>(args)...);
 
 #ifdef STAN_DETERMINISTIC
     tbb::static_partitioner partitioner;
@@ -150,15 +153,14 @@ struct reduce_sum_impl<ReduceFunction, require_arithmetic_t<ReturnType>,
  * that any internal state of the functor is causing trouble. Thus,
  * the functor must be default constructible without any arguments.
  */
-template <typename ReduceFunction, typename Vec, typename = require_vector_like_t<Vec>,
-          typename... Args>
+template <typename ReduceFunction, typename Vec,
+          typename = require_vector_like_t<Vec>, typename... Args>
 auto reduce_sum(Vec&& vmapped, std::size_t grainsize, std::ostream* msgs,
                 Args&&... args) {
   using return_type = return_type_t<Vec, Args...>;
   return internal::reduce_sum_impl<ReduceFunction, void, return_type, Vec,
-                                   Args...>()(std::forward<Vec>(vmapped),
-                                              grainsize, msgs,
-                                              std::forward<Args>(args)...);
+                                   Args...>()(
+      std::forward<Vec>(vmapped), grainsize, msgs, std::forward<Args>(args)...);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 19af0ed820f..37d91c98fec 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -31,13 +31,13 @@ template <typename ReduceFunction, typename ReturnType, typename Vec,
           typename... Args>
 struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
                        Vec, Args...> {
- /**
-  * Internal object used in `tbb::parallel_reduce`
-  * @note see link [here](https://tinyurl.com/vp7xw2t) for requirements.
-  */
+  /**
+   * Internal object used in `tbb::parallel_reduce`
+   * @note see link [here](https://tinyurl.com/vp7xw2t) for requirements.
+   */
   struct recursive_reducer {
-    size_t num_shared_terms_; // Number of terms shared across threads
-    double* sliced_partials_; // Points to adjoints of the partial calculations
+    size_t num_shared_terms_;  // Number of terms shared across threads
+    double* sliced_partials_;  // Points to adjoints of the partial calculations
     Vec vmapped_;
     std::ostream* msgs_;
     std::tuple<Args...> args_tuple_;
@@ -46,8 +46,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
 
     template <typename VecT, typename... ArgsT>
     recursive_reducer(size_t num_shared_terms, double* sliced_partials,
-                      VecT&& vmapped, std::ostream* msgs,
-                      ArgsT&&... args)
+                      VecT&& vmapped, std::ostream* msgs, ArgsT&&... args)
         : num_shared_terms_(num_shared_terms),
           sliced_partials_(sliced_partials),
           vmapped_(std::forward<VecT>(vmapped)),
@@ -67,7 +66,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
      * @param arg For lvalue references this will be passed by reference.
      *  Otherwise it will be moved.
      */
-    template <typename Arith, typename = require_arithmetic_t<scalar_type_t<Arith>>>
+    template <typename Arith,
+              typename = require_arithmetic_t<scalar_type_t<Arith>>>
     inline decltype(auto) deep_copy(Arith&& arg) {
       return std::forward<Arith>(arg);
     }
@@ -116,9 +116,10 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
      */
     template <typename EigT, require_eigen_vt<is_var, EigT>* = nullptr>
     inline auto deep_copy(EigT&& arg) {
-      return arg.unaryExpr([](auto&& x) {
-         return var(new vari(x.val(), false));
-       }).eval();;
+      return arg
+          .unaryExpr([](auto&& x) { return var(new vari(x.val(), false)); })
+          .eval();
+      ;
     }
 
     /**
@@ -143,7 +144,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
      * @param x A vector of vars to accumulate the adjoint of.
      * @param args Further args to accumulate over.
      */
-    template <typename VarVec, require_std_vector_vt<is_var, VarVec>* = nullptr, typename... Pargs>
+    template <typename VarVec, require_std_vector_vt<is_var, VarVec>* = nullptr,
+              typename... Pargs>
     inline double* accumulate_adjoints(double* dest, VarVec&& x,
                                        Pargs&&... args) {
       for (auto&& x_iter : x) {
@@ -154,16 +156,18 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     }
 
     /**
-     * Accumulates adjoints for a standard vector of containers within the reduce.
-     * @tparam VecContainer the type of a standard container holding var containers.
+     * Accumulates adjoints for a standard vector of containers within the
+     * reduce.
+     * @tparam VecContainer the type of a standard container holding var
+     * containers.
      * @tparam Pargs types of further arguments to accumulate over.
      * @param dest points to values holding adjoint accumulate.
      * @param x A vector of var containers to accumulate the adjoint of.
      * @param args Further args to accumulate over.
      */
     template <typename VecContainer,
-        require_std_vector_st<is_var, VecContainer>* = nullptr,
-        require_std_vector_vt<is_container, VecContainer>* = nullptr,
+              require_std_vector_st<is_var, VecContainer>* = nullptr,
+              require_std_vector_vt<is_container, VecContainer>* = nullptr,
               typename... Pargs>
     inline double* accumulate_adjoints(double* dest, VecContainer&& x,
                                        Pargs&&... args) {
@@ -230,8 +234,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
       }
       auto args_tuple_local_copy = apply(
           [&](auto&&... args) {
-            return std::tuple<decltype(deep_copy(args))...>(
-                deep_copy(args)...);
+            return std::tuple<decltype(deep_copy(args))...>(deep_copy(args)...);
           },
           this->args_tuple_);
       var sub_sum_v = apply(
@@ -246,7 +249,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
       apply(
           [&](auto&&... args) {
             return accumulate_adjoints(args_adjoints_.data(),
-             std::forward<decltype(args)>(args)...);
+                                       std::forward<decltype(args)>(args)...);
           },
           std::move(args_tuple_local_copy));
     }
@@ -262,7 +265,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
       this->sum_ += rhs.sum_;
       if (this->args_adjoints_.size() != 0 && rhs.args_adjoints_.size() != 0) {
         this->args_adjoints_ += rhs.args_adjoints_;
-      } else if (this->args_adjoints_.size() == 0 && rhs.args_adjoints_.size() != 0) {
+      } else if (this->args_adjoints_.size() == 0
+                 && rhs.args_adjoints_.size() != 0) {
         this->args_adjoints_ = rhs.args_adjoints_;
       }
     }
@@ -274,11 +278,13 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
    * @tparam Pargs Types to be forwarded to recursive call of `count_var_impl`.
    * @param[in] count The current count of the number of vars.
    * @param[in] x A vector holding vars.
-   * @param[in] args objects to be forwarded to recursive call of `count_var_impl`
+   * @param[in] args objects to be forwarded to recursive call of
+   * `count_var_impl`
    */
-  template <typename VecVar, require_std_vector_vt<is_var, VecVar>* = nullptr, typename... Pargs>
+  template <typename VecVar, require_std_vector_vt<is_var, VecVar>* = nullptr,
+            typename... Pargs>
   inline size_t count_var_impl(size_t count, VecVar&& x,
-                        Pargs&&... args) const {
+                               Pargs&&... args) const {
     return count_var_impl(count + x.size(), std::forward<Pargs>(args)...);
   }
 
@@ -288,12 +294,15 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
    * @tparam Pargs Types to be forwarded to recursive call of `count_var_impl`.
    * @param[in] count The current count of the number of vars.
    * @param[in] x A vector holding containers of vars.
-   * @param[in] args objects to be forwarded to recursive call of `count_var_impl`
+   * @param[in] args objects to be forwarded to recursive call of
+   * `count_var_impl`
    */
-  template <typename VecContainer, require_std_vector_st<is_var, VecContainer>* = nullptr,
+  template <typename VecContainer,
+            require_std_vector_st<is_var, VecContainer>* = nullptr,
             require_std_vector_vt<is_container, VecContainer>* = nullptr,
             typename... Pargs>
-  inline size_t count_var_impl(size_t count, VecContainer&& x, Pargs&&... args) const {
+  inline size_t count_var_impl(size_t count, VecContainer&& x,
+                               Pargs&&... args) const {
     for (auto&& x_iter : x) {
       count = count_var_impl(count, x_iter);
     }
@@ -305,7 +314,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
    * @tparam Pargs Types to be forwarded to recursive call of `count_var_impl`.
    * @param[in] count The current count of the number of vars.
    * @param[in] x An Eigen container holding vars.
-   * @param[in] args objects to be forwarded to recursive call of `count_var_impl`
+   * @param[in] args objects to be forwarded to recursive call of
+   * `count_var_impl`
    */
   template <typename EigT, require_eigen_vt<is_var, EigT>* = nullptr,
             typename... Pargs>
@@ -318,20 +328,25 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
    * @tparam Pargs Types to be forwarded to recursive call of `count_var_impl`.
    * @param[in] count The current count of the number of vars.
    * @param[in] x A var.
-   * @param[in] args objects to be forwarded to recursive call of `count_var_impl`
+   * @param[in] args objects to be forwarded to recursive call of
+   * `count_var_impl`
    */
   template <typename... Pargs>
-  inline size_t count_var_impl(size_t count, const var& x, Pargs&&... args) const {
+  inline size_t count_var_impl(size_t count, const var& x,
+                               Pargs&&... args) const {
     return count_var_impl(count + 1, std::forward<Pargs>(args)...);
   }
 
   /**
-   * Specialization that performs skips count for arithmetic types and containers.
-   * @tparam Arith An object that is either arithmetic or holds arithmetic types.
+   * Specialization that performs skips count for arithmetic types and
+   * containers.
+   * @tparam Arith An object that is either arithmetic or holds arithmetic
+   * types.
    * @tparam Pargs Types to be forwarded to recursive call of `count_var_impl`.
    * @param[in] count The current count of the number of vars.
    * @param[in] x An arithmetic value or container.
-   * @param[in] args objects to be forwarded to recursive call of `count_var_impl`
+   * @param[in] args objects to be forwarded to recursive call of
+   * `count_var_impl`
    */
   template <typename Arith,
             require_arithmetic_t<scalar_type_t<Arith>>* = nullptr,
@@ -387,7 +402,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   }
 
   /**
-   * Store a reference to an std vector of containers's `vari` used in `reduce_sum`.
+   * Store a reference to an std vector of containers's `vari` used in
+   * `reduce_sum`.
    * @tparam VecContainer Type of standard vector holding containers of vars.
    * @tparam Pargs Types to be forwarded to recursive call of `save_varis`.
    * @param[in, out] dest Pointer to set of varis.
@@ -398,7 +414,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
             require_std_vector_st<is_var, VecContainer>* = nullptr,
             require_std_vector_vt<is_container, VecContainer>* = nullptr,
             typename... Pargs>
-  inline vari** save_varis(vari** dest, VecContainer&& x, Pargs&&... args) const {
+  inline vari** save_varis(vari** dest, VecContainer&& x,
+                           Pargs&&... args) const {
     for (size_t i = 0; i < x.size(); ++i) {
       dest = save_varis(dest, x[i]);
     }
@@ -418,20 +435,23 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   inline vari** save_varis(vari** dest, EigT&& x, Pargs&&... args) const {
     using mat_t = std::decay_t<EigT>;
     using write_map = Eigen::Map<Eigen::Matrix<vari*, mat_t::RowsAtCompileTime,
-     mat_t::ColsAtCompileTime>>;
+                                               mat_t::ColsAtCompileTime>>;
     write_map(dest, x.rows(), x.cols()) = x.vi();
     return save_varis(dest + x.size(), std::forward<Pargs>(args)...);
   }
 
   /**
-   * Specialization to skip over arithmetic types and containers of arithmetic types.
-   * @tparam Arith either an arithmetic type or container holding arithmetic types.
+   * Specialization to skip over arithmetic types and containers of arithmetic
+   * types.
+   * @tparam Arith either an arithmetic type or container holding arithmetic
+   * types.
    * @tparam Pargs Types to be forwarded to recursive call of `save_varis`.
    * @param[in, out] dest Pointer to set of varis.
    * @param[in] x arithmetic or container of arithmetics.
    * @param[in] args Further arguments forwarded to recursive call.
    */
-  template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>* = nullptr,
+  template <typename Arith,
+            require_arithmetic_t<scalar_type_t<Arith>>* = nullptr,
             typename... Pargs>
   inline vari** save_varis(vari** dest, Arith&& x, Pargs&&... args) const {
     return save_varis(dest, std::forward<Pargs>(args)...);
@@ -444,14 +464,14 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
   inline vari** save_varis(vari** dest) const { return dest; }
 
   template <typename OpVec, typename... OpArgs,
-  typename = require_same_t<Vec, OpVec>,
-  typename = require_all_t<std::is_same<Args, OpArgs>...>>
-  inline var operator()(OpVec&& vmapped, std::size_t grainsize, std::ostream* msgs,
-                 OpArgs&&... args) const {
+            typename = require_same_t<Vec, OpVec>,
+            typename = require_all_t<std::is_same<Args, OpArgs>...>>
+  inline var operator()(OpVec&& vmapped, std::size_t grainsize,
+                        std::ostream* msgs, OpArgs&&... args) const {
     const std::size_t num_jobs = vmapped.size();
 
     if (num_jobs == 0) {
-      return var(0.0);      
+      return var(0.0);
     }
 
     const std::size_t num_sliced_terms = count_var(vmapped);
diff --git a/test/unit/math/mix/functor/reduce_sum_test.cpp b/test/unit/math/mix/functor/reduce_sum_test.cpp
index 88f54714ccc..6f540b1313f 100644
--- a/test/unit/math/mix/functor/reduce_sum_test.cpp
+++ b/test/unit/math/mix/functor/reduce_sum_test.cpp
@@ -27,15 +27,14 @@ auto sum_(Vec&& arg) {
 
 struct sum_lpdf {
   template <typename T, typename... Args>
-  inline auto operator()(std::size_t start, std::size_t end,
-                         T&& sub_slice, std::ostream* msgs,
-                         Args&&... args) const {
+  inline auto operator()(std::size_t start, std::size_t end, T&& sub_slice,
+                         std::ostream* msgs, Args&&... args) const {
     using return_type = stan::return_type_t<T, Args...>;
 
     return stan::math::sum(sub_slice)
            + sub_slice.size()
-                 * stan::math::sum(
-                       std::vector<return_type>{return_type(sum_(std::forward<Args>(args)))...});
+                 * stan::math::sum(std::vector<return_type>{
+                       return_type(sum_(std::forward<Args>(args)))...});
   }
 };
 
@@ -51,9 +50,8 @@ TEST(MathMix_reduce_sum, double_slice) {
 
 struct start_end_lpdf {
   template <typename T1, typename T2>
-  inline auto operator()(std::size_t start, std::size_t end,
-                         T1&&, std::ostream* msgs,
-                         T2&& data) const {
+  inline auto operator()(std::size_t start, std::size_t end, T1&&,
+                         std::ostream* msgs, T2&& data) const {
     stan::return_type_t<T1, T2> sum = 0;
     EXPECT_GE(start, 0);
     EXPECT_LE(end, data.size() - 1);
@@ -195,7 +193,7 @@ TEST(MathMix_reduce_sum, eigen_three_args_with_ints2) {
   Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
 
   stan::test::expect_ad(
-    [&](auto&& arg1, auto&& arg2, auto&& arg3) {
+      [&](auto&& arg1, auto&& arg2, auto&& arg3) {
         return fi(1, arg1, std::vector<int>{1, 2, 3}, arg2, 3, arg3);
       },
       arg1, arg2, arg3);
diff --git a/test/unit/math/rev/functor/reduce_sum_test.cpp b/test/unit/math/rev/functor/reduce_sum_test.cpp
index e5a2b9387f0..e3cb95c8820 100644
--- a/test/unit/math/rev/functor/reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/reduce_sum_test.cpp
@@ -174,9 +174,8 @@ struct grouped_count_lpdf {
 
   // does the reduction in the sub-slice start to end
   template <typename VecInt1, typename VecT, typename VecInt2>
-  inline T operator()(std::size_t start, std::size_t end,
-                      VecInt1&& sub_slice, std::ostream* msgs,
-                      VecT&& lambda, VecInt2&& gidx) const {
+  inline T operator()(std::size_t start, std::size_t end, VecInt1&& sub_slice,
+                      std::ostream* msgs, VecT&& lambda, VecInt2&& gidx) const {
     const std::size_t num_terms = end - start + 1;
     // std::cout << "sub-slice " << start << " - " << end << "; num_terms = " <<
     // num_terms << "; size = " << sub_slice.size() << std::endl;

From cc37f22f531461dbf5a64aa35e9ae2aebda6f6d8 Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Mon, 9 Mar 2020 17:25:09 -0400
Subject: [PATCH 092/189] Add includes for test-headers and add threading
 environment variable to jenkins

---
 Jenkinsfile                             | 16 +++++++++-------
 stan/math/prim/functor/left_fold.hpp    |  1 +
 stan/math/rev/functor/adj_jac_apply.hpp |  3 ++-
 stan/math/rev/functor/reduce_sum.hpp    |  1 -
 4 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index e0fe062664d..13554aaf7c3 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -164,7 +164,7 @@ pipeline {
         stage('Verify changes') {
             agent { label 'linux' }
             steps {
-                script {         
+                script {
 
                     retry(3) { checkout scm }
                     sh 'git clean -xffd'
@@ -259,7 +259,7 @@ pipeline {
                         deleteDir()
                         unstash 'MathSetup'
                         sh "echo CXX=${MPICXX} >> make/local"
-                        sh "echo CXX_TYPE=gcc >> make/local"                        
+                        sh "echo CXX_TYPE=gcc >> make/local"
                         sh "echo STAN_MPI=true >> make/local"
                         runTests("test/unit")
                     }
@@ -319,6 +319,7 @@ pipeline {
                     steps {
                         deleteDir()
                         unstash 'MathSetup'
+                        sh "export STAN_NUM_THREADS=2"
                         sh "echo CXX=${env.CXX} -Werror > make/local"
                         sh "echo CPPFLAGS+=-DSTAN_THREADS >> make/local"
                         runTests("test/unit -f thread")
@@ -342,6 +343,7 @@ pipeline {
                     steps {
                         deleteDirWin()
                         unstash 'MathSetup'
+                        bat "setx STAN_NUM_THREADS 2"
                         bat "echo CXX=${env.CXX} -Werror > make/local"
                         bat "echo CXXFLAGS+=-DSTAN_THREADS >> make/local"
                         runTestsWin("test/unit -f thread")
@@ -351,7 +353,7 @@ pipeline {
             }
         }
         stage('Additional merge tests') {
-            when { 
+            when {
                 allOf {
                     anyOf {
                         branch 'develop'
@@ -388,12 +390,12 @@ pipeline {
             }
         }
         stage('Upstream tests') {
-            when { 
+            when {
                 allOf {
-                    expression { 
-                        env.BRANCH_NAME ==~ /PR-\d+/ 
+                    expression {
+                        env.BRANCH_NAME ==~ /PR-\d+/
                     }
-                    expression { 
+                    expression {
                         !skipRemainingStages
                     }
                 }
diff --git a/stan/math/prim/functor/left_fold.hpp b/stan/math/prim/functor/left_fold.hpp
index 211a781d0c7..4373e92b95b 100644
--- a/stan/math/prim/functor/left_fold.hpp
+++ b/stan/math/prim/functor/left_fold.hpp
@@ -1,6 +1,7 @@
 #ifndef STAN_MATH_PRIM_SCAL_FUNCTOR_LEFT_FOLD_HPP
 #define STAN_MATH_PRIM_SCAL_FUNCTOR_LEFT_FOLD_HPP
 
+#include <stan/math/prim/meta.hpp>
 #include <functional>
 #include <tuple>
 #include <utility>
diff --git a/stan/math/rev/functor/adj_jac_apply.hpp b/stan/math/rev/functor/adj_jac_apply.hpp
index a848386c6a2..2ce3598338e 100644
--- a/stan/math/rev/functor/adj_jac_apply.hpp
+++ b/stan/math/rev/functor/adj_jac_apply.hpp
@@ -1,9 +1,10 @@
 #ifndef STAN_MATH_REV_FUNCTOR_ADJ_JAC_APPLY_HPP
 #define STAN_MATH_REV_FUNCTOR_ADJ_JAC_APPLY_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/fun/value_of.hpp>
-#include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/functor/apply.hpp>
 #include <stan/math/prim/fun/value_of.hpp>
 #include <stan/math/prim/fun/constants.hpp>
 #include <tuple>
diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 37d91c98fec..4e6ebb213a3 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -119,7 +119,6 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
       return arg
           .unaryExpr([](auto&& x) { return var(new vari(x.val(), false)); })
           .eval();
-      ;
     }
 
     /**

From b64fe8745e7c57baf3e9927b10966d0c1840659b Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Mon, 9 Mar 2020 17:39:07 -0400
Subject: [PATCH 093/189] remove -fopenmp from CXXFLAGS

---
 make/compiler_flags | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/make/compiler_flags b/make/compiler_flags
index 700c15533af..93f48f8b2e4 100644
--- a/make/compiler_flags
+++ b/make/compiler_flags
@@ -252,7 +252,7 @@ endif
 
 
 
-CXXFLAGS += -fopenmp $(CXXFLAGS_LANG) $(CXXFLAGS_OS) $(CXXFLAGS_WARNINGS) $(CXXFLAGS_BOOST) $(CXXFLAGS_EIGEN) $(CXXFLAGS_OPENCL) $(CXXFLAGS_MPI) $(CXXFLAGS_THREADS) $(CXXFLAGS_TBB) -O$(O) $(INC)
+CXXFLAGS += $(CXXFLAGS_LANG) $(CXXFLAGS_OS) $(CXXFLAGS_WARNINGS) $(CXXFLAGS_BOOST) $(CXXFLAGS_EIGEN) $(CXXFLAGS_OPENCL) $(CXXFLAGS_MPI) $(CXXFLAGS_THREADS) $(CXXFLAGS_TBB) -O$(O) $(INC)
 CPPFLAGS += $(CPPFLAGS_LANG) $(CPPFLAGS_OS) $(CPPFLAGS_WARNINGS) $(CPPFLAGS_BOOST) $(CPPFLAGS_EIGEN) $(CPPFLAGS_OPENCL) $(CPPFLAGS_MPI) $(CPPFLAGS_TBB)
 LDFLAGS += $(LDFLAGS_LANG) $(LDFLAGS_OS) $(LDFLAGS_WARNINGS) $(LDFLAGS_BOOST) $(LDFLAGS_EIGEN) $(LDFLAGS_OPENCL) $(LDFLAGS_MPI) $(LDFLAGS_TBB)
 LDLIBS += $(LDLIBS_LANG) $(LDLIBS_OS) $(LDLIBS_WARNINGS) $(LDLIBS_BOOST) $(LDLIBS_EIGEN) $(LDLIBS_OPENCL) $(LDLIBS_MPI) $(LDLIBS_TBB)

From 7d27f90b2b7c1f1655ce937972597e683cba5b0d Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Tue, 10 Mar 2020 02:10:43 -0400
Subject: [PATCH 094/189] remove old prim/scal.hpp include from apply_test

---
 test/unit/math/prim/functor/apply_test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/unit/math/prim/functor/apply_test.cpp b/test/unit/math/prim/functor/apply_test.cpp
index 74744a1d4f8..c852f74ba93 100644
--- a/test/unit/math/prim/functor/apply_test.cpp
+++ b/test/unit/math/prim/functor/apply_test.cpp
@@ -1,4 +1,4 @@
-#include <stan/math/prim/scal.hpp>
+#include <stan/math/prim.hpp>
 #include <gtest/gtest.h>
 #include <tuple>
 #include <type_traits>

From c53d29d1d0365b17160517b40adf0c1b2d83596d Mon Sep 17 00:00:00 2001
From: Steve Bronder <stevo15025@gmail.com>
Date: Tue, 10 Mar 2020 18:13:51 -0400
Subject: [PATCH 095/189] Fix broadcast_array to remove vec_partial_

---
 stan/math/prim/meta/broadcast_array.hpp       | 33 +++++++++++--------
 stan/math/prim/meta/operands_and_partials.hpp |  2 --
 stan/math/rev/functor/adj_jac_apply.hpp       |  2 +-
 3 files changed, 20 insertions(+), 17 deletions(-)

diff --git a/stan/math/prim/meta/broadcast_array.hpp b/stan/math/prim/meta/broadcast_array.hpp
index e105f9e2f87..94cfa2235e8 100644
--- a/stan/math/prim/meta/broadcast_array.hpp
+++ b/stan/math/prim/meta/broadcast_array.hpp
@@ -13,13 +13,14 @@ namespace internal {
 template <typename T>
 class broadcast_array {
  private:
-  T& prim_;
+  using T_decay = std::decay_t<T>;
+  T_decay& prim_;
 
  public:
   explicit broadcast_array(T& prim) : prim_(prim) {}
 
-  T& operator[](int /*i*/) { return prim_; }
-  T& operator[](int /*i*/) const { return prim_; }
+  auto& operator[](int /*i*/) { return prim_; }
+  auto& operator[](int /*i*/) const { return prim_; }
 
   /** \ingroup type_trait
    * We can assign any right hand side which allows for indexing to a
@@ -31,7 +32,7 @@ class broadcast_array {
   void operator=(const Y& m) {
     prim_ = m[0];
   }
-  broadcast_array& operator=(broadcast_array other) {
+  broadcast_array& operator=(broadcast_array& other) {
     prim_ = other.prim_;
     return *this;
   }
@@ -39,20 +40,24 @@ class broadcast_array {
 
 template <typename T, typename S, typename Enable = void>
 class empty_broadcast_array {
+ using T_decay = std::decay_t<T>;
  public:
   empty_broadcast_array() {}
   /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
-  T& operator[](int /*i*/);
-  T& operator[](int /*i*/) const;
+  T_decay& operator[](int /*i*/);
+  T_decay& operator[](int /*i*/) const;
 
-  /** \ingroup type_trait
+  /**
    * Not implemented so cannot be called.
    */
   template <typename Y>
   void operator=(const Y& /*A*/);
 
+  /**
+   * Not implemented so cannot be called.
+   */
   template <typename R>
   void operator+=(R);
 };
@@ -64,31 +69,31 @@ class empty_broadcast_array<ViewElt, T, require_eigen_t<T>> {
 
  public:
   empty_broadcast_array() {}
-  /** \ingroup type_trait
+  /**
    * Not implemented so cannot be called.
    */
   ViewElt& operator[](int /*i*/);
-  /** \ingroup type_trait
+  /**
    * Not implemented so cannot be called.
    */
   ViewElt& operator()(int /*i*/);
-  /** \ingroup type_trait
+  /**
    * Not implemented so cannot be called.
    */
   void operator=(const T_arg& /*A*/);
-  /** \ingroup type_trait
+  /**
    * Not implemented so cannot be called.
    */
   void operator+=(T_arg /*A*/);
-  /** \ingroup type_trait
+  /**
    * Not implemented so cannot be called.
    */
   void operator-=(T_arg /*A*/);
-  /** \ingroup type_trait
+  /**
    * Not implemented so cannot be called.
    */
   T& row(int /*i*/);
-  /** \ingroup type_trait
+  /**
    * Not implemented so cannot be called.
    */
   T& col(int /*i*/);
diff --git a/stan/math/prim/meta/operands_and_partials.hpp b/stan/math/prim/meta/operands_and_partials.hpp
index 1c775c53649..b553b9ee0a6 100644
--- a/stan/math/prim/meta/operands_and_partials.hpp
+++ b/stan/math/prim/meta/operands_and_partials.hpp
@@ -2,7 +2,6 @@
 #define STAN_MATH_PRIM_META_OPERANDS_AND_PARTIALS_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/meta/require_generics.hpp>
 #include <stan/math/prim/meta/broadcast_array.hpp>
 #include <stan/math/prim/meta/return_type.hpp>
 #include <vector>
@@ -40,7 +39,6 @@ template <typename ViewElt, typename Op, typename Enable = void>
 class ops_partials_edge {
  public:
   empty_broadcast_array<ViewElt, Op> partials_;
-  empty_broadcast_array<ViewElt, Op> partials_vec_;
 
   ops_partials_edge() {}
   explicit ops_partials_edge(const Op& /* op */) {}
diff --git a/stan/math/rev/functor/adj_jac_apply.hpp b/stan/math/rev/functor/adj_jac_apply.hpp
index 2ce3598338e..8bcf4c33754 100644
--- a/stan/math/rev/functor/adj_jac_apply.hpp
+++ b/stan/math/rev/functor/adj_jac_apply.hpp
@@ -507,7 +507,7 @@ struct adj_jac_vari : public vari {
     internal::build_y_adj(y_vi_, M_, y_adj);
     auto y_adj_jacs = f_.multiply_adjoint_jacobian(is_var_, y_adj);
 
-    apply([this](auto&&... args) { this->accumulate_adjoints(args...); },
+    apply([&](auto&&... args) { this->accumulate_adjoints(args...); },
           y_adj_jacs);
   }
 };

From fb9f25a13f3b5c07df50500d43cb4fd2ebe52111 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Tue, 10 Mar 2020 22:14:35 +0000
Subject: [PATCH 096/189] [Jenkins] auto-formatting by clang-format version
 5.0.0-3~16.04.1 (tags/RELEASE_500/final)

---
 stan/math/prim/meta/broadcast_array.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stan/math/prim/meta/broadcast_array.hpp b/stan/math/prim/meta/broadcast_array.hpp
index 94cfa2235e8..183732c287a 100644
--- a/stan/math/prim/meta/broadcast_array.hpp
+++ b/stan/math/prim/meta/broadcast_array.hpp
@@ -40,7 +40,8 @@ class broadcast_array {
 
 template <typename T, typename S, typename Enable = void>
 class empty_broadcast_array {
- using T_decay = std::decay_t<T>;
+  using T_decay = std::decay_t<T>;
+
  public:
   empty_broadcast_array() {}
   /** \ingroup type_trait

From 86bf06acb64b62547569838c4ca3c0c9c0e8b005 Mon Sep 17 00:00:00 2001
From: rok-cesnovar <rok.cesnovar@fri.uni-lj.si>
Date: Wed, 11 Mar 2020 14:31:21 +0100
Subject: [PATCH 097/189] a few inlines added

---
 stan/math/rev/fun/accumulate_adjoints.hpp |  2 +-
 stan/math/rev/fun/count_vars.hpp          |  2 +-
 stan/math/rev/fun/deep_copy.hpp           | 10 +++++-----
 stan/math/rev/fun/save_varis.hpp          |  2 +-
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/stan/math/rev/fun/accumulate_adjoints.hpp b/stan/math/rev/fun/accumulate_adjoints.hpp
index b0c043d1325..d3bf86494f5 100644
--- a/stan/math/rev/fun/accumulate_adjoints.hpp
+++ b/stan/math/rev/fun/accumulate_adjoints.hpp
@@ -10,7 +10,7 @@ namespace math {
 
 namespace internal {
 
-double* accumulate_adjoints(double* x) { return x; }
+inline double* accumulate_adjoints(double* x) { return x; }
 
 template <typename... Pargs>
 double* accumulate_adjoints(double* dest, const var& x, const Pargs&... args);
diff --git a/stan/math/rev/fun/count_vars.hpp b/stan/math/rev/fun/count_vars.hpp
index 5ec641bfe8f..10154670de2 100644
--- a/stan/math/rev/fun/count_vars.hpp
+++ b/stan/math/rev/fun/count_vars.hpp
@@ -10,7 +10,7 @@ namespace math {
 
 namespace internal {
 
-size_t count_vars_impl(size_t count) { return count; }
+inline size_t count_vars_impl(size_t count) { return count; }
 
 template <typename... Pargs>
 size_t count_vars_impl(size_t count, const std::vector<var>& x,
diff --git a/stan/math/rev/fun/deep_copy.hpp b/stan/math/rev/fun/deep_copy.hpp
index 5f783a05ec2..eb0e005cf0c 100644
--- a/stan/math/rev/fun/deep_copy.hpp
+++ b/stan/math/rev/fun/deep_copy.hpp
@@ -11,13 +11,13 @@ namespace math {
 namespace internal {
 
 template <typename T, require_arithmetic_t<scalar_type_t<T>>...>
-const T& deep_copy(const T& arg) {
+inline const T& deep_copy(const T& arg) {
   return arg;
 }
 
-var deep_copy(const var& arg) { return var(new vari(arg.val(), false)); }
+inline var deep_copy(const var& arg) { return var(new vari(arg.val(), false)); }
 
-std::vector<var> deep_copy(const std::vector<var>& arg) {
+inline std::vector<var> deep_copy(const std::vector<var>& arg) {
   std::vector<var> copy(arg.size());
   for (size_t i = 0; i < arg.size(); ++i) {
     copy[i] = new vari(arg[i].val(), false);
@@ -26,7 +26,7 @@ std::vector<var> deep_copy(const std::vector<var>& arg) {
 }
 
 template <typename T, require_t<is_var<scalar_type_t<T>>>...>
-std::vector<T> deep_copy(const std::vector<T>& arg) {
+inline std::vector<T> deep_copy(const std::vector<T>& arg) {
   std::vector<T> copy(arg.size());
   for (size_t i = 0; i < arg.size(); ++i) {
     copy[i] = deep_copy(arg[i]);
@@ -35,7 +35,7 @@ std::vector<T> deep_copy(const std::vector<T>& arg) {
 }
 
 template <int RowType, int ColType>
-Eigen::Matrix<var, RowType, ColType> deep_copy(
+inline Eigen::Matrix<var, RowType, ColType> deep_copy(
     const Eigen::Matrix<var, RowType, ColType>& arg) {
   Eigen::Matrix<var, RowType, ColType> copy(arg.rows(), arg.cols());
   for (size_t i = 0; i < arg.size(); ++i) {
diff --git a/stan/math/rev/fun/save_varis.hpp b/stan/math/rev/fun/save_varis.hpp
index df3044b401a..d0ac38e99c3 100644
--- a/stan/math/rev/fun/save_varis.hpp
+++ b/stan/math/rev/fun/save_varis.hpp
@@ -10,7 +10,7 @@ namespace math {
 
 namespace internal {
 
-vari** save_varis(vari** dest) { return dest; }
+inline vari** save_varis(vari** dest) { return dest; }
 
 template <typename... Pargs>
 vari** save_varis(vari** dest, const var& x, const Pargs&... args);

From 7aa19cecd46ef08239932ce2eefb8a3e949d2d37 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Fri, 13 Mar 2020 09:48:25 -0400
Subject: [PATCH 098/189] Changed reduce_sum so sliced argument can be an array
 of any Stan type

---
 stan/math/rev/functor/reduce_sum.hpp          |  34 ++--
 .../unit/math/mix/functor/reduce_sum_test.cpp |  43 ++++-
 .../math/prim/functor/reduce_sum_test.cpp     | 177 +++++-------------
 3 files changed, 109 insertions(+), 145 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 4e6ebb213a3..6066e2f4a28 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -36,6 +36,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
    * @note see link [here](https://tinyurl.com/vp7xw2t) for requirements.
    */
   struct recursive_reducer {
+    size_t per_job_sliced_terms_;
     size_t num_shared_terms_;  // Number of terms shared across threads
     double* sliced_partials_;  // Points to adjoints of the partial calculations
     Vec vmapped_;
@@ -45,20 +46,22 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     Eigen::VectorXd args_adjoints_{0};
 
     template <typename VecT, typename... ArgsT>
-    recursive_reducer(size_t num_shared_terms, double* sliced_partials,
+    recursive_reducer(size_t per_job_sliced_terms, size_t num_shared_terms, double* sliced_partials,
                       VecT&& vmapped, std::ostream* msgs, ArgsT&&... args)
-        : num_shared_terms_(num_shared_terms),
-          sliced_partials_(sliced_partials),
-          vmapped_(std::forward<VecT>(vmapped)),
-          msgs_(msgs),
-          args_tuple_(std::forward<ArgsT>(args)...) {}
+      : per_job_sliced_terms_(per_job_sliced_terms),
+	num_shared_terms_(num_shared_terms),
+	sliced_partials_(sliced_partials),
+	vmapped_(std::forward<VecT>(vmapped)),
+	msgs_(msgs),
+	args_tuple_(std::forward<ArgsT>(args)...) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-        : num_shared_terms_(other.num_shared_terms_),
-          sliced_partials_(other.sliced_partials_),
-          vmapped_(other.vmapped_),
-          msgs_(other.msgs_),
-          args_tuple_(other.args_tuple_) {}
+      : per_job_sliced_terms_(other.per_job_sliced_terms_),
+	num_shared_terms_(other.num_shared_terms_),
+	sliced_partials_(other.sliced_partials_),
+	vmapped_(other.vmapped_),
+	msgs_(other.msgs_),
+	args_tuple_(other.args_tuple_) {}
 
     /**
      * Specialization of deep copy that returns references for arithmetic types.
@@ -244,7 +247,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
           args_tuple_local_copy);
       sub_sum_v.grad();
       sum_ += sub_sum_v.val();
-      accumulate_adjoints(this->sliced_partials_ + r.begin(), local_sub_slice);
+      accumulate_adjoints(this->sliced_partials_ + r.begin() * per_job_sliced_terms_, local_sub_slice);
       apply(
           [&](auto&&... args) {
             return accumulate_adjoints(args_adjoints_.data(),
@@ -473,7 +476,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
       return var(0.0);
     }
 
-    const std::size_t num_sliced_terms = count_var(vmapped);
+    const std::size_t per_job_sliced_terms = count_var(vmapped[0]);
+    const std::size_t num_sliced_terms = num_jobs * per_job_sliced_terms;
     const std::size_t num_shared_terms = count_var(args...);
 
     vari** varis = ChainableStack::instance_->memalloc_.alloc_array<vari*>(
@@ -484,8 +488,8 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     for (size_t i = 0; i < num_sliced_terms; ++i) {
       partials[i] = 0.0;
     }
-    recursive_reducer worker(num_shared_terms, partials, vmapped, msgs,
-                             args...);
+    recursive_reducer worker(per_job_sliced_terms, num_shared_terms, partials,
+			     vmapped, msgs, args...);
 
 #ifdef STAN_DETERMINISTIC
     tbb::inline_partitioner partitioner;
diff --git a/test/unit/math/mix/functor/reduce_sum_test.cpp b/test/unit/math/mix/functor/reduce_sum_test.cpp
index 6f540b1313f..75298fa0626 100644
--- a/test/unit/math/mix/functor/reduce_sum_test.cpp
+++ b/test/unit/math/mix/functor/reduce_sum_test.cpp
@@ -31,7 +31,7 @@ struct sum_lpdf {
                          std::ostream* msgs, Args&&... args) const {
     using return_type = stan::return_type_t<T, Args...>;
 
-    return stan::math::sum(sub_slice)
+    return sum_(sub_slice)
            + sub_slice.size()
                  * stan::math::sum(std::vector<return_type>{
                        return_type(sum_(std::forward<Args>(args)))...});
@@ -48,6 +48,46 @@ TEST(MathMix_reduce_sum, double_slice) {
   stan::test::expect_ad(f, data);
 }
 
+TEST(MathMix_reduce_sum, std_vector_double_slice) {
+  auto f = [](auto&& data) {
+    return stan::math::reduce_sum<sum_lpdf>(data, 0, msgs);
+  };
+
+  std::vector<std::vector<double>> data(3, std::vector<double>(2, 10.0));
+
+  stan::test::expect_ad(f, data);
+}
+
+TEST(MathMix_reduce_sum, vector_double_slice) {
+  auto f = [](auto&& data) {
+    return stan::math::reduce_sum<sum_lpdf>(data, 0, msgs);
+  };
+
+  std::vector<Eigen::VectorXd> data(3, Eigen::VectorXd::Ones(2));
+
+  stan::test::expect_ad(f, data);
+}
+
+TEST(MathMix_reduce_sum, row_vector_double_slice) {
+  auto f = [](auto&& data) {
+    return stan::math::reduce_sum<sum_lpdf>(data, 0, msgs);
+  };
+
+  std::vector<Eigen::RowVectorXd> data(3, Eigen::RowVectorXd::Ones(2));
+
+  stan::test::expect_ad(f, data);
+}
+
+TEST(MathMix_reduce_sum, matrix_double_slice) {
+  auto f = [](auto&& data) {
+    return stan::math::reduce_sum<sum_lpdf>(data, 0, msgs);
+  };
+
+  std::vector<Eigen::MatrixXd> data(3, Eigen::MatrixXd::Ones(2, 4));
+
+  stan::test::expect_ad(f, data);
+}
+
 struct start_end_lpdf {
   template <typename T1, typename T2>
   inline auto operator()(std::size_t start, std::size_t end, T1&&,
@@ -249,3 +289,4 @@ TEST(MathMix_reduce_sum, eigen_three_args_with_doubles3) {
       },
       arg1, arg2, arg3);
 }
+
diff --git a/test/unit/math/prim/functor/reduce_sum_test.cpp b/test/unit/math/prim/functor/reduce_sum_test.cpp
index 63c248452e0..831e5c4a8d3 100644
--- a/test/unit/math/prim/functor/reduce_sum_test.cpp
+++ b/test/unit/math/prim/functor/reduce_sum_test.cpp
@@ -89,19 +89,35 @@ TEST(StanMathPrim_reduce_sum, nesting_value) {
   EXPECT_FLOAT_EQ(poisson_lpdf, poisson_lpdf_ref);
 }
 
-struct int_slice_lpdf {
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<int>& sub_slice,
-                         std::ostream* msgs) const {
-    return stan::math::sum(sub_slice);
+template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
+T sum_(T arg) {
+  return arg;
+}
+
+template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
+auto sum_(EigMat&& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
+auto sum_(Vec&& arg) {
+  stan::scalar_type_t<Vec> sum = 0;
+  for (size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
   }
-};
+  return sum;
+}
 
-struct double_slice_lpdf {
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<double>& sub_slice,
-                         std::ostream* msgs) const {
-    return stan::math::sum(sub_slice);
+struct sum_lpdf {
+  template <typename T, typename... Args>
+  inline auto operator()(std::size_t start, std::size_t end, T&& sub_slice,
+                         std::ostream* msgs, Args&&... args) const {
+    using return_type = stan::return_type_t<T, Args...>;
+
+    return sum_(sub_slice)
+           + sub_slice.size()
+                 * stan::math::sum(std::vector<return_type>{
+                       return_type(sum_(std::forward<Args>(args)))...});
   }
 };
 
@@ -110,7 +126,7 @@ TEST(StanMathPrim_reduce_sum, int_slice) {
 
   std::vector<int> data(5, 10);
 
-  EXPECT_EQ(50, stan::math::reduce_sum<int_slice_lpdf>(data, 0, msgs));
+  EXPECT_EQ(50, stan::math::reduce_sum<sum_lpdf>(data, 0, msgs));
 }
 
 TEST(StanMathPrim_reduce_sum, double_slice) {
@@ -119,7 +135,16 @@ TEST(StanMathPrim_reduce_sum, double_slice) {
   std::vector<double> data(5, 10.0);
 
   EXPECT_DOUBLE_EQ(50.0,
-                   stan::math::reduce_sum<double_slice_lpdf>(data, 0, msgs));
+                   stan::math::reduce_sum<sum_lpdf>(data, 0, msgs));
+}
+
+TEST(StanMathPrim_reduce_sum, std_vector_double_slice) {
+  stan::math::init_threadpool_tbb();
+
+  std::vector<std::vector<double>> data(5, std::vector<double>(2, 10.0));
+
+  EXPECT_DOUBLE_EQ(100.0,
+                   stan::math::reduce_sum<sum_lpdf>(data, 0, msgs));
 }
 
 struct start_end_lpdf {
@@ -144,65 +169,6 @@ TEST(StanMathPrim_reduce_sum, start_end_slice) {
   EXPECT_EQ(50, stan::math::reduce_sum<start_end_lpdf>(data, 0, msgs, data));
 }
 
-struct int_arg_lpdf {
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<double>& sub_slice,
-                         std::ostream* msgs, const int& arg) const {
-    return stan::math::sum(sub_slice) + sub_slice.size() * arg;
-  }
-};
-
-struct double_arg_lpdf {
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<double>& sub_slice,
-                         std::ostream* msgs, const double& arg) const {
-    return stan::math::sum(sub_slice) + sub_slice.size() * arg;
-  }
-};
-
-struct std_vector_int_arg_lpdf {
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<double>& sub_slice,
-                         std::ostream* msgs,
-                         const std::vector<int>& arg) const {
-    return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
-  }
-};
-
-struct std_vector_double_arg_lpdf {
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<double>& sub_slice,
-                         std::ostream* msgs,
-                         const std::vector<double>& arg) const {
-    return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
-  }
-};
-
-struct eigen_vector_arg_lpdf {
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<double>& sub_slice,
-                         std::ostream* msgs, const Eigen::VectorXd& arg) const {
-    return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
-  }
-};
-
-struct eigen_row_vector_arg_lpdf {
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<double>& sub_slice,
-                         std::ostream* msgs,
-                         const Eigen::RowVectorXd& arg) const {
-    return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
-  }
-};
-
-struct eigen_matrix_arg_lpdf {
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<double>& sub_slice,
-                         std::ostream* msgs, const Eigen::MatrixXd& arg) const {
-    return stan::math::sum(sub_slice) + sub_slice.size() * stan::math::sum(arg);
-  }
-};
-
 TEST(StanMathPrim_reduce_sum, int_arg) {
   stan::math::init_threadpool_tbb();
 
@@ -210,7 +176,7 @@ TEST(StanMathPrim_reduce_sum, int_arg) {
   int arg = 5;
 
   EXPECT_DOUBLE_EQ(5 * (10 + 5),
-                   stan::math::reduce_sum<int_arg_lpdf>(data, 0, msgs, arg));
+                   stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMathPrim_reduce_sum, double_arg) {
@@ -220,7 +186,7 @@ TEST(StanMathPrim_reduce_sum, double_arg) {
   double arg = 5.0;
 
   EXPECT_DOUBLE_EQ(5 * (10.0 + 5.0),
-                   stan::math::reduce_sum<double_arg_lpdf>(data, 0, msgs, arg));
+                   stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMathPrim_reduce_sum, std_vector_int_arg) {
@@ -231,7 +197,7 @@ TEST(StanMathPrim_reduce_sum, std_vector_int_arg) {
 
   EXPECT_DOUBLE_EQ(
       5 * (10 + 5 * 10),
-      stan::math::reduce_sum<std_vector_int_arg_lpdf>(data, 0, msgs, arg));
+      stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMathPrim_reduce_sum, std_vector_double_arg) {
@@ -242,7 +208,7 @@ TEST(StanMathPrim_reduce_sum, std_vector_double_arg) {
 
   EXPECT_DOUBLE_EQ(
       5 * (10 + 5 * 10),
-      stan::math::reduce_sum<std_vector_double_arg_lpdf>(data, 0, msgs, arg));
+      stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMathPrim_reduce_sum, eigen_vector_arg) {
@@ -251,7 +217,7 @@ TEST(StanMathPrim_reduce_sum, eigen_vector_arg) {
   std::vector<double> data(5, 10.0);
   Eigen::VectorXd arg = Eigen::VectorXd::Ones(5);
 
-  EXPECT_DOUBLE_EQ(5 * (10 + 5), stan::math::reduce_sum<eigen_vector_arg_lpdf>(
+  EXPECT_DOUBLE_EQ(5 * (10 + 5), stan::math::reduce_sum<sum_lpdf>(
                                      data, 0, msgs, arg));
 }
 
@@ -263,7 +229,7 @@ TEST(StanMathPrim_reduce_sum, eigen_row_vector_arg) {
 
   EXPECT_DOUBLE_EQ(
       5 * (10 + 5),
-      stan::math::reduce_sum<eigen_row_vector_arg_lpdf>(data, 0, msgs, arg));
+      stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMathPrim_reduce_sum, eigen_matrix_arg) {
@@ -274,33 +240,9 @@ TEST(StanMathPrim_reduce_sum, eigen_matrix_arg) {
 
   EXPECT_DOUBLE_EQ(
       5 * (10 + 5 * 5),
-      stan::math::reduce_sum<eigen_matrix_arg_lpdf>(data, 0, msgs, arg));
+      stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
 }
 
-struct std_vector_std_vector_double_arg_lpdf {
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<double>& sub_slice,
-                         std::ostream* msgs,
-                         const std::vector<std::vector<double>>& arg) const {
-    double sum = 0.0;
-    for (size_t i = 0; i < arg.size(); ++i)
-      sum += stan::math::sum(arg[i]);
-    return stan::math::sum(sub_slice) + sub_slice.size() * sum;
-  }
-};
-
-struct std_vector_eigen_vector_arg_lpdf {
-  inline auto operator()(std::size_t start, std::size_t end,
-                         const std::vector<double>& sub_slice,
-                         std::ostream* msgs,
-                         const std::vector<Eigen::VectorXd>& arg) const {
-    double sum = 0.0;
-    for (size_t i = 0; i < arg.size(); ++i)
-      sum += stan::math::sum(arg[i]);
-    return stan::math::sum(sub_slice) + sub_slice.size() * sum;
-  }
-};
-
 TEST(StanMathPrim_reduce_sum, std_vector_std_vector_double_arg) {
   stan::math::init_threadpool_tbb();
 
@@ -309,8 +251,7 @@ TEST(StanMathPrim_reduce_sum, std_vector_std_vector_double_arg) {
 
   EXPECT_DOUBLE_EQ(
       5 * (10 + 250),
-      stan::math::reduce_sum<std_vector_std_vector_double_arg_lpdf>(data, 0,
-                                                                    msgs, arg));
+      stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMathPrim_reduce_sum, std_vector_eigen_vector_arg) {
@@ -320,32 +261,10 @@ TEST(StanMathPrim_reduce_sum, std_vector_eigen_vector_arg) {
   std::vector<Eigen::VectorXd> arg(2, Eigen::VectorXd::Ones(5));
 
   EXPECT_DOUBLE_EQ(5 * (10 + 10),
-                   stan::math::reduce_sum<std_vector_eigen_vector_arg_lpdf>(
+                   stan::math::reduce_sum<sum_lpdf>(
                        data, 0, msgs, arg));
 }
 
-struct sum_lpdf {
-  inline auto operator()(
-      std::size_t start, std::size_t end, const std::vector<double>& sub_slice,
-      std::ostream* msgs, const int& arg1, const double& arg2,
-      const std::vector<int>& arg3, const std::vector<double>& arg4,
-      const Eigen::VectorXd& arg5, const Eigen::RowVectorXd& arg6,
-      const Eigen::MatrixXd& arg7, const std::vector<std::vector<double>>& arg8,
-      const std::vector<Eigen::VectorXd>& arg9) const {
-    double sum8 = 0.0;
-    double sum9 = 0.0;
-    for (size_t i = 0; i < arg8.size(); ++i)
-      sum8 += stan::math::sum(arg8[i]);
-    for (size_t i = 0; i < arg9.size(); ++i)
-      sum9 += stan::math::sum(arg9[i]);
-    return stan::math::sum(sub_slice)
-           + sub_slice.size()
-                 * (arg1 + arg2 + stan::math::sum(arg3) + stan::math::sum(arg4)
-                    + stan::math::sum(arg5) + stan::math::sum(arg6)
-                    + stan::math::sum(arg7) + sum8 + sum9);
-  }
-};
-
 TEST(StanMathPrim_reduce_sum, sum) {
   stan::math::init_threadpool_tbb();
 
@@ -363,5 +282,5 @@ TEST(StanMathPrim_reduce_sum, sum) {
   EXPECT_DOUBLE_EQ(
       5 + 5 * (1 + 1 + 5 + 5 + 5 + 5 + 25 + 10 + 10),
       stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg1, arg2, arg3, arg4,
-                                       arg5, arg6, arg7, arg8, arg9));
+					arg5, arg6, arg7, arg8, arg9));
 }

From 09d3f52ce1770793f50b1705f7768ef99a78ec1b Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 13 Mar 2020 09:50:19 -0400
Subject: [PATCH 099/189] [Jenkins] auto-formatting by clang-format version
 5.0.2-svn328729-1~exp1~20180509124008.99 (branches/release_50)

---
 stan/math/rev/functor/reduce_sum.hpp          | 35 ++++++++--------
 .../unit/math/mix/functor/reduce_sum_test.cpp |  1 -
 .../math/prim/functor/reduce_sum_test.cpp     | 40 ++++++++-----------
 3 files changed, 35 insertions(+), 41 deletions(-)

diff --git a/stan/math/rev/functor/reduce_sum.hpp b/stan/math/rev/functor/reduce_sum.hpp
index 6066e2f4a28..f0d87901454 100644
--- a/stan/math/rev/functor/reduce_sum.hpp
+++ b/stan/math/rev/functor/reduce_sum.hpp
@@ -46,22 +46,23 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
     Eigen::VectorXd args_adjoints_{0};
 
     template <typename VecT, typename... ArgsT>
-    recursive_reducer(size_t per_job_sliced_terms, size_t num_shared_terms, double* sliced_partials,
-                      VecT&& vmapped, std::ostream* msgs, ArgsT&&... args)
-      : per_job_sliced_terms_(per_job_sliced_terms),
-	num_shared_terms_(num_shared_terms),
-	sliced_partials_(sliced_partials),
-	vmapped_(std::forward<VecT>(vmapped)),
-	msgs_(msgs),
-	args_tuple_(std::forward<ArgsT>(args)...) {}
+    recursive_reducer(size_t per_job_sliced_terms, size_t num_shared_terms,
+                      double* sliced_partials, VecT&& vmapped,
+                      std::ostream* msgs, ArgsT&&... args)
+        : per_job_sliced_terms_(per_job_sliced_terms),
+          num_shared_terms_(num_shared_terms),
+          sliced_partials_(sliced_partials),
+          vmapped_(std::forward<VecT>(vmapped)),
+          msgs_(msgs),
+          args_tuple_(std::forward<ArgsT>(args)...) {}
 
     recursive_reducer(recursive_reducer& other, tbb::split)
-      : per_job_sliced_terms_(other.per_job_sliced_terms_),
-	num_shared_terms_(other.num_shared_terms_),
-	sliced_partials_(other.sliced_partials_),
-	vmapped_(other.vmapped_),
-	msgs_(other.msgs_),
-	args_tuple_(other.args_tuple_) {}
+        : per_job_sliced_terms_(other.per_job_sliced_terms_),
+          num_shared_terms_(other.num_shared_terms_),
+          sliced_partials_(other.sliced_partials_),
+          vmapped_(other.vmapped_),
+          msgs_(other.msgs_),
+          args_tuple_(other.args_tuple_) {}
 
     /**
      * Specialization of deep copy that returns references for arithmetic types.
@@ -247,7 +248,9 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
           args_tuple_local_copy);
       sub_sum_v.grad();
       sum_ += sub_sum_v.val();
-      accumulate_adjoints(this->sliced_partials_ + r.begin() * per_job_sliced_terms_, local_sub_slice);
+      accumulate_adjoints(
+          this->sliced_partials_ + r.begin() * per_job_sliced_terms_,
+          local_sub_slice);
       apply(
           [&](auto&&... args) {
             return accumulate_adjoints(args_adjoints_.data(),
@@ -489,7 +492,7 @@ struct reduce_sum_impl<ReduceFunction, require_var_t<ReturnType>, ReturnType,
       partials[i] = 0.0;
     }
     recursive_reducer worker(per_job_sliced_terms, num_shared_terms, partials,
-			     vmapped, msgs, args...);
+                             vmapped, msgs, args...);
 
 #ifdef STAN_DETERMINISTIC
     tbb::inline_partitioner partitioner;
diff --git a/test/unit/math/mix/functor/reduce_sum_test.cpp b/test/unit/math/mix/functor/reduce_sum_test.cpp
index 75298fa0626..689f0544cb0 100644
--- a/test/unit/math/mix/functor/reduce_sum_test.cpp
+++ b/test/unit/math/mix/functor/reduce_sum_test.cpp
@@ -289,4 +289,3 @@ TEST(MathMix_reduce_sum, eigen_three_args_with_doubles3) {
       },
       arg1, arg2, arg3);
 }
-
diff --git a/test/unit/math/prim/functor/reduce_sum_test.cpp b/test/unit/math/prim/functor/reduce_sum_test.cpp
index 831e5c4a8d3..595a0382a42 100644
--- a/test/unit/math/prim/functor/reduce_sum_test.cpp
+++ b/test/unit/math/prim/functor/reduce_sum_test.cpp
@@ -134,8 +134,7 @@ TEST(StanMathPrim_reduce_sum, double_slice) {
 
   std::vector<double> data(5, 10.0);
 
-  EXPECT_DOUBLE_EQ(50.0,
-                   stan::math::reduce_sum<sum_lpdf>(data, 0, msgs));
+  EXPECT_DOUBLE_EQ(50.0, stan::math::reduce_sum<sum_lpdf>(data, 0, msgs));
 }
 
 TEST(StanMathPrim_reduce_sum, std_vector_double_slice) {
@@ -143,8 +142,7 @@ TEST(StanMathPrim_reduce_sum, std_vector_double_slice) {
 
   std::vector<std::vector<double>> data(5, std::vector<double>(2, 10.0));
 
-  EXPECT_DOUBLE_EQ(100.0,
-                   stan::math::reduce_sum<sum_lpdf>(data, 0, msgs));
+  EXPECT_DOUBLE_EQ(100.0, stan::math::reduce_sum<sum_lpdf>(data, 0, msgs));
 }
 
 struct start_end_lpdf {
@@ -195,9 +193,8 @@ TEST(StanMathPrim_reduce_sum, std_vector_int_arg) {
   std::vector<double> data(5, 10.0);
   std::vector<int> arg(5, 10);
 
-  EXPECT_DOUBLE_EQ(
-      5 * (10 + 5 * 10),
-      stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
+  EXPECT_DOUBLE_EQ(5 * (10 + 5 * 10),
+                   stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMathPrim_reduce_sum, std_vector_double_arg) {
@@ -206,9 +203,8 @@ TEST(StanMathPrim_reduce_sum, std_vector_double_arg) {
   std::vector<double> data(5, 10.0);
   std::vector<double> arg(5, 10.0);
 
-  EXPECT_DOUBLE_EQ(
-      5 * (10 + 5 * 10),
-      stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
+  EXPECT_DOUBLE_EQ(5 * (10 + 5 * 10),
+                   stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMathPrim_reduce_sum, eigen_vector_arg) {
@@ -217,8 +213,8 @@ TEST(StanMathPrim_reduce_sum, eigen_vector_arg) {
   std::vector<double> data(5, 10.0);
   Eigen::VectorXd arg = Eigen::VectorXd::Ones(5);
 
-  EXPECT_DOUBLE_EQ(5 * (10 + 5), stan::math::reduce_sum<sum_lpdf>(
-                                     data, 0, msgs, arg));
+  EXPECT_DOUBLE_EQ(5 * (10 + 5),
+                   stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMathPrim_reduce_sum, eigen_row_vector_arg) {
@@ -227,9 +223,8 @@ TEST(StanMathPrim_reduce_sum, eigen_row_vector_arg) {
   std::vector<double> data(5, 10.0);
   Eigen::RowVectorXd arg = Eigen::RowVectorXd::Ones(5);
 
-  EXPECT_DOUBLE_EQ(
-      5 * (10 + 5),
-      stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
+  EXPECT_DOUBLE_EQ(5 * (10 + 5),
+                   stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMathPrim_reduce_sum, eigen_matrix_arg) {
@@ -238,9 +233,8 @@ TEST(StanMathPrim_reduce_sum, eigen_matrix_arg) {
   std::vector<double> data(5, 10.0);
   Eigen::MatrixXd arg = Eigen::MatrixXd::Ones(5, 5);
 
-  EXPECT_DOUBLE_EQ(
-      5 * (10 + 5 * 5),
-      stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
+  EXPECT_DOUBLE_EQ(5 * (10 + 5 * 5),
+                   stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMathPrim_reduce_sum, std_vector_std_vector_double_arg) {
@@ -249,9 +243,8 @@ TEST(StanMathPrim_reduce_sum, std_vector_std_vector_double_arg) {
   std::vector<double> data(5, 10.0);
   std::vector<std::vector<double>> arg(5, std::vector<double>(5, 10.0));
 
-  EXPECT_DOUBLE_EQ(
-      5 * (10 + 250),
-      stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
+  EXPECT_DOUBLE_EQ(5 * (10 + 250),
+                   stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMathPrim_reduce_sum, std_vector_eigen_vector_arg) {
@@ -261,8 +254,7 @@ TEST(StanMathPrim_reduce_sum, std_vector_eigen_vector_arg) {
   std::vector<Eigen::VectorXd> arg(2, Eigen::VectorXd::Ones(5));
 
   EXPECT_DOUBLE_EQ(5 * (10 + 10),
-                   stan::math::reduce_sum<sum_lpdf>(
-                       data, 0, msgs, arg));
+                   stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg));
 }
 
 TEST(StanMathPrim_reduce_sum, sum) {
@@ -282,5 +274,5 @@ TEST(StanMathPrim_reduce_sum, sum) {
   EXPECT_DOUBLE_EQ(
       5 + 5 * (1 + 1 + 5 + 5 + 5 + 5 + 25 + 10 + 10),
       stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, arg1, arg2, arg3, arg4,
-					arg5, arg6, arg7, arg8, arg9));
+                                       arg5, arg6, arg7, arg8, arg9));
 }

From 80449e0ff2a49becc8057bbebc79af7edfae3e51 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 13 Mar 2020 21:12:19 -0400
Subject: [PATCH 100/189] [Jenkins] auto-formatting by clang-format version
 6.0.0 (tags/google/stable/2017-11-14)

---
 stan/math/prim/functor/coupled_ode_system.hpp |  54 +++---
 stan/math/prim/functor/integrate_ode_rk45.hpp |  22 +--
 stan/math/rev/functor/coupled_ode_system.hpp  | 147 ++++++++++-------
 stan/math/rev/functor/cvodes_integrator.hpp   | 156 ++++++++++--------
 stan/math/rev/functor/integrate_ode_adams.hpp |   9 +-
 stan/math/rev/functor/integrate_ode_bdf.hpp   |   9 +-
 stan/math/rev/functor/ode_bdf.hpp             |  22 +--
 .../math/rev/functor/ode_bdf_prim_test.cpp    | 116 +++++++------
 8 files changed, 290 insertions(+), 245 deletions(-)

diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
index e9de342fe6d..83501b59716 100644
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -60,10 +60,12 @@ namespace math {
  * msgs)</code>
  */
 
-template <bool Enable, typename T_initial, typename T_t0, typename T_ts, typename F, typename... Args>
+template <bool Enable, typename T_initial, typename T_t0, typename T_ts,
+          typename F, typename... Args>
 struct coupled_ode_system_impl;
-  
-template <typename T_initial, typename T_t0, typename T_ts, typename F, typename... Args>
+
+template <typename T_initial, typename T_t0, typename T_ts, typename F,
+          typename... Args>
 struct coupled_ode_system_impl<true, T_initial, T_t0, T_ts, F, Args...> {
   const F& f_;
   const std::vector<double>& y0_;
@@ -84,28 +86,25 @@ struct coupled_ode_system_impl<true, T_initial, T_t0, T_ts, F, Args...> {
    * @param[in, out] msgs stream for messages
    */
   coupled_ode_system_impl(const F& f, const std::vector<double>& y0,
-			  const Args&... args, std::ostream* msgs)
-      : f_(f),
-        y0_(y0),
-	args_tuple_(args...),
-        N_(y0.size()),
-        msgs_(msgs) {
-  }
+                          const Args&... args, std::ostream* msgs)
+      : f_(f), y0_(y0), args_tuple_(args...), N_(y0.size()), msgs_(msgs) {}
 
   void operator()(const std::vector<double>& y, std::vector<double>& dy_dt,
                   double t) const {
-    dy_dt = apply([&](const Args&... args) {
-	return f_.template operator()<double, double, Args...>(t, y, args..., msgs_);
-      }, args_tuple_);
+    dy_dt = apply(
+        [&](const Args&... args) {
+          return f_.template operator()<double, double, Args...>(t, y, args...,
+                                                                 msgs_);
+        },
+        args_tuple_);
 
     check_size_match("coupled_ode_system", "y", y.size(), "dy_dt",
                      dy_dt.size());
   }
 
   std::vector<double> build_output(const std::vector<double>& dy0_dt0,
-				   const std::vector<double>& coupled_state,
-				   const double& t0,
-				   const double& t) const {
+                                   const std::vector<double>& coupled_state,
+                                   const double& t0, const double& t) const {
     return std::vector<double>(coupled_state.data(), coupled_state.data() + N_);
   }
 
@@ -134,19 +133,22 @@ struct coupled_ode_system_impl<true, T_initial, T_t0, T_ts, F, Args...> {
    *   elements are all zero as these are the Jacobian wrt to the
    *   parameters at the initial time-point, which is zero.
    */
-  std::vector<double> initial_state() const {
-    return value_of(y0_);
-  }
+  std::vector<double> initial_state() const { return value_of(y0_); }
 };
 
-template <typename T_initial, typename T_t0, typename T_ts, typename F, typename... Args>
-struct coupled_ode_system :
-    public coupled_ode_system_impl<std::is_arithmetic<return_type_t<T_initial, T_t0, T_ts, Args...>>::value,
-				   T_initial, T_t0, T_ts, F, Args...> {
+template <typename T_initial, typename T_t0, typename T_ts, typename F,
+          typename... Args>
+struct coupled_ode_system
+    : public coupled_ode_system_impl<
+          std::is_arithmetic<
+              return_type_t<T_initial, T_t0, T_ts, Args...>>::value,
+          T_initial, T_t0, T_ts, F, Args...> {
   coupled_ode_system(const F& f, const std::vector<T_initial>& y0,
-		     const Args&... args, std::ostream* msgs)
-    : coupled_ode_system_impl<std::is_arithmetic<return_type_t<T_initial, T_t0, T_ts, Args...>>::value,
-			      T_initial, T_t0, T_ts, F, Args...>(f, y0, args..., msgs) {}
+                     const Args&... args, std::ostream* msgs)
+      : coupled_ode_system_impl<std::is_arithmetic<return_type_t<
+                                    T_initial, T_t0, T_ts, Args...>>::value,
+                                T_initial, T_t0, T_ts, F, Args...>(
+            f, y0, args..., msgs) {}
 };
 
 }  // namespace math
diff --git a/stan/math/prim/functor/integrate_ode_rk45.hpp b/stan/math/prim/functor/integrate_ode_rk45.hpp
index 37a42113ef7..c6b8131da49 100644
--- a/stan/math/prim/functor/integrate_ode_rk45.hpp
+++ b/stan/math/prim/functor/integrate_ode_rk45.hpp
@@ -67,15 +67,14 @@ namespace math {
  * same size as the state variable, corresponding to a time in ts.
  */
 
-template <typename... Args, typename F, typename T1, typename T_t0, typename T_ts>
-std::vector<std::vector<return_type_t<T1, T_t0, T_ts, Args...>>> integrate_ode_rk45(
-    const F& f, const std::vector<T1>& y0, const T_t0& t0,
-    const std::vector<T_ts>& ts,
-    const Args&... args,
-    std::ostream* msgs = nullptr,
-    double relative_tolerance = 1e-6,
-    double absolute_tolerance = 1e-6,
-    int max_num_steps = 1e6) {
+template <typename... Args, typename F, typename T1, typename T_t0,
+          typename T_ts>
+std::vector<std::vector<return_type_t<T1, T_t0, T_ts, Args...>>>
+integrate_ode_rk45(const F& f, const std::vector<T1>& y0, const T_t0& t0,
+                   const std::vector<T_ts>& ts, const Args&... args,
+                   std::ostream* msgs = nullptr,
+                   double relative_tolerance = 1e-6,
+                   double absolute_tolerance = 1e-6, int max_num_steps = 1e6) {
   using boost::numeric::odeint::integrate_times;
   using boost::numeric::odeint::make_dense_output;
   using boost::numeric::odeint::max_step_checker;
@@ -114,7 +113,8 @@ std::vector<std::vector<return_type_t<T1, T_t0, T_ts, Args...>>> integrate_ode_r
 
   using return_t = return_type_t<T1, T_t0, T_ts, Args...>;
   // creates basic or coupled system by template specializations
-  coupled_ode_system<T1, T_t0, T_ts, F, Args...> coupled_system(f, y0, args..., msgs);
+  coupled_ode_system<T1, T_t0, T_ts, F, Args...> coupled_system(f, y0, args...,
+                                                                msgs);
 
   // first time in the vector must be time of initial state
   std::vector<double> ts_vec(ts.size() + 1);
@@ -124,7 +124,7 @@ std::vector<std::vector<return_type_t<T1, T_t0, T_ts, Args...>>> integrate_ode_r
   std::vector<std::vector<return_t>> y;
   bool observer_initial_recorded = false;
   size_t time_index = 0;
-  
+
   // avoid recording of the initial state which is included by the
   // conventions of odeint in the output
   auto filtered_observer
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index 3909ecbec5e..af6eb75eadb 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -62,7 +62,8 @@ namespace math {
  *          std::vector<double> x, std::vector<int>x_int, std::ostream*
  * msgs)</code>
  */
-template <typename T_initial, typename T_t0, typename T_ts, typename F, typename... Args>
+template <typename T_initial, typename T_t0, typename T_ts, typename F,
+          typename... Args>
 struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
   using T_Return = return_type_t<T_initial, T_t0, T_ts, Args...>;
 
@@ -87,7 +88,7 @@ struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
    * @param[in, out] msgs stream for messages
    */
   coupled_ode_system_impl(const F& f, const std::vector<T_initial>& y0,
-			  const Args&... args, std::ostream* msgs)
+                          const Args&... args, std::ostream* msgs)
       : f_(f),
         y0_(y0),
         args_tuple_(args...),
@@ -119,15 +120,18 @@ struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
 
     const vector<var> y_vars(z.begin(), z.begin() + N_);
     auto local_args_tuple = apply(
-				  [&](auto&&... args) {
-				    return std::tuple<decltype(internal::deep_copy(args))...>(
-											      internal::deep_copy(args)...);
-				  },
-				  args_tuple_);
-    
+        [&](auto&&... args) {
+          return std::tuple<decltype(internal::deep_copy(args))...>(
+              internal::deep_copy(args)...);
+        },
+        args_tuple_);
+
     vector<var> dy_dt_vars = apply(
-				   [&](auto&&... args) { return f_.template operator()<double, var, decltype(args)...>(t, y_vars, args..., msgs_); },
-				   local_args_tuple);
+        [&](auto&&... args) {
+          return f_.template operator()<double, var, decltype(args)...>(
+              t, y_vars, args..., msgs_);
+        },
+        local_args_tuple);
 
     check_size_match("coupled_ode_system", "dz_dt", dy_dt_vars.size(), "states",
                      N_);
@@ -136,64 +140,76 @@ struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
       dz_dt[i] = dy_dt_vars[i].val();
       dy_dt_vars[i].grad();
       for (size_t j = 0; j < y0_vars_; j++) {
-	// orders derivatives by equation (i.e. if there are 2 eqns
-	// (y1, y2) and 2 parameters (a, b), dy_dt will be ordered as:
-	// dy1_dt, dy2_dt, dy1_da, dy2_da, dy1_db, dy2_db
-	double temp_deriv = 0;
-	const size_t offset = N_ + N_ * j;
-	for (size_t k = 0; k < N_; k++) {
-	  temp_deriv += z[N_ + N_ * j + k] * y_vars[k].adj();
-	}
-	
-	dz_dt[N_ + N_ * j + i] = temp_deriv;
+        // orders derivatives by equation (i.e. if there are 2 eqns
+        // (y1, y2) and 2 parameters (a, b), dy_dt will be ordered as:
+        // dy1_dt, dy2_dt, dy1_da, dy2_da, dy1_db, dy2_db
+        double temp_deriv = 0;
+        const size_t offset = N_ + N_ * j;
+        for (size_t k = 0; k < N_; k++) {
+          temp_deriv += z[N_ + N_ * j + k] * y_vars[k].adj();
+        }
+
+        dz_dt[N_ + N_ * j + i] = temp_deriv;
       }
-      
+
       Eigen::VectorXd args_adjoints = Eigen::VectorXd::Zero(args_vars_);
       apply(
-	    [&](auto&&... args) {
-	      internal::accumulate_adjoints(args_adjoints.data(), args...);
-	    },
-	    local_args_tuple);
+          [&](auto&&... args) {
+            internal::accumulate_adjoints(args_adjoints.data(), args...);
+          },
+          local_args_tuple);
       for (size_t j = 0; j < args_vars_; j++) {
-	double temp_deriv = args_adjoints(j);
-	for (size_t k = 0; k < N_; k++) {
-	  temp_deriv += z[N_ + N_ * y0_vars_ + N_ * j + k] * y_vars[k].adj();
-	}
-	
-	dz_dt[N_ + N_ * y0_vars_ + N_ * j + i] = temp_deriv;
+        double temp_deriv = args_adjoints(j);
+        for (size_t k = 0; k < N_; k++) {
+          temp_deriv += z[N_ + N_ * y0_vars_ + N_ * j + k] * y_vars[k].adj();
+        }
+
+        dz_dt[N_ + N_ * y0_vars_ + N_ * j + i] = temp_deriv;
       }
-      
+
       nested.set_zero_all_adjoints();
     }
   }
 
-  template<typename T_t>
-  std::vector<var> build_output(const std::vector<double>& dy0_dt0, const std::vector<double>& coupled_state, const T_t0& t0, const T_t& t) const {
+  template <typename T_t>
+  std::vector<var> build_output(const std::vector<double>& dy0_dt0,
+                                const std::vector<double>& coupled_state,
+                                const T_t0& t0, const T_t& t) const {
     std::vector<double> y_dbl(coupled_state.data(), coupled_state.data() + N_);
 
     std::vector<var> yt;
     yt.reserve(N_);
-    
+
     std::vector<double> dy_dt;
     if (is_var<T_t>::value) {
       std::vector<double> y_dbl(coupled_state.begin(),
                                 coupled_state.begin() + N_);
       /*vector<var> dy_dt_vars = apply([&](const Args&... args) {
-	  return f_(t, y_vars, args..., msgs_);
-	  }, local_args_tuple);*/
-      dy_dt = apply([&](auto&&... args) {
-	  return f_.template operator()<double, double, decltype(value_of(args))...>(value_of(t), y_dbl, value_of(args)..., msgs_);
-	}, args_tuple_);
-      check_size_match("coupled_ode_observer", "dy_dt", dy_dt.size(), "states", N_);
+          return f_(t, y_vars, args..., msgs_);
+          }, local_args_tuple);*/
+      dy_dt = apply(
+          [&](auto&&... args) {
+            return f_.template
+            operator()<double, double, decltype(value_of(args))...>(
+                value_of(t), y_dbl, value_of(args)..., msgs_);
+          },
+          args_tuple_);
+      check_size_match("coupled_ode_observer", "dy_dt", dy_dt.size(), "states",
+                       N_);
     }
-    
+
     for (size_t j = 0; j < N_; j++) {
       // When true this is 1 and not ts_.size() because there's
       //   only one time point involved with this output
-      const size_t total_vars = y0_vars_ + args_vars_ + ((is_var<T_t>::value) ? 1 : 0) + ((is_var<T_t0>::value) ? 1 : 0);
+      const size_t total_vars = y0_vars_ + args_vars_
+                                + ((is_var<T_t>::value) ? 1 : 0)
+                                + ((is_var<T_t0>::value) ? 1 : 0);
 
-      vari** varis = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
-      double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(total_vars);
+      vari** varis
+          = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
+      double* partials
+          = ChainableStack::instance_->memalloc_.alloc_array<double>(
+              total_vars);
 
       vari** varis_ptr = varis;
       double* partials_ptr = partials;
@@ -201,36 +217,39 @@ struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
       // iterate over parameters for each equation
       varis_ptr = internal::save_varis(varis_ptr, y0_);
       for (std::size_t k = 0; k < y0_vars_; k++) {
-	//*varis_ptr = y0[k].vi_;
-	*partials_ptr = coupled_state[N_ + y0_vars_ * k + j];
-	partials_ptr++;
+        //*varis_ptr = y0[k].vi_;
+        *partials_ptr = coupled_state[N_ + y0_vars_ * k + j];
+        partials_ptr++;
       }
 
-      varis_ptr = apply([&varis_ptr](auto&&... args) {
-	  return internal::save_varis(varis_ptr, args...);
-	}, args_tuple_);
+      varis_ptr = apply(
+          [&varis_ptr](auto&&... args) {
+            return internal::save_varis(varis_ptr, args...);
+          },
+          args_tuple_);
       for (std::size_t k = 0; k < args_vars_; k++) {
-	// dy[j]_dtheta[k]
-	// theta[k].vi_
-	*partials_ptr = coupled_state[N_ + N_ * y0_vars_ + N_ * k + j];
-	partials_ptr++;
+        // dy[j]_dtheta[k]
+        // theta[k].vi_
+        *partials_ptr = coupled_state[N_ + N_ * y0_vars_ + N_ * k + j];
+        partials_ptr++;
       }
 
       if ((stan::is_var<T_t>::value) ? 1 : 0) {
-	varis_ptr = internal::save_varis(varis_ptr, t);
-	*partials_ptr = dy_dt[j];
-	partials_ptr++;
-	// dy[j]_dcurrent_t
+        varis_ptr = internal::save_varis(varis_ptr, t);
+        *partials_ptr = dy_dt[j];
+        partials_ptr++;
+        // dy[j]_dcurrent_t
       }
 
       if ((stan::is_var<T_t0>::value) ? 1 : 0) {
-	varis_ptr = internal::save_varis(varis_ptr, t0);
-	*partials_ptr = -dy0_dt0[j];
-	partials_ptr++;
-	// dy[j]_dcurrent_t
+        varis_ptr = internal::save_varis(varis_ptr, t0);
+        *partials_ptr = -dy0_dt0[j];
+        partials_ptr++;
+        // dy[j]_dcurrent_t
       }
 
-      yt.emplace_back(new precomputed_gradients_vari(coupled_state[j], total_vars, varis, partials));
+      yt.emplace_back(new precomputed_gradients_vari(
+          coupled_state[j], total_vars, varis, partials));
     }
 
     return yt;
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 0f195ce1079..b8323a2ed2e 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -21,8 +21,8 @@ namespace math {
  *
  * @tparam Lmm ID of ODE solver (1: ADAMS, 2: BDF)
  */
-template <int Lmm, typename F, typename T_initial,
-	  typename T_t0, typename T_ts, typename... T_Args>
+template <int Lmm, typename F, typename T_initial, typename T_t0, typename T_ts,
+          typename... T_Args>
 class cvodes_integrator {
   using T_Return = return_type_t<T_initial, T_t0, T_ts, T_Args...>;
 
@@ -48,26 +48,26 @@ class cvodes_integrator {
   SUNMatrix A_;
   SUNLinearSolver LS_;
 
-public:
-  cvodes_integrator(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
-		    const std::vector<T_ts>& ts, const T_Args&... args,
-		    std::ostream* msgs, double relative_tolerance,
-		    double absolute_tolerance,
-		    long int max_num_steps)
-    : f_(f),
-      y0_(y0),
-      t0_(t0),
-      ts_(ts),
-      args_tuple_(args...),
-      N_(y0.size()),
-      msgs_(msgs),
-      relative_tolerance_(relative_tolerance),
-      absolute_tolerance_(absolute_tolerance),
-      max_num_steps_(max_num_steps),
-      y0_vars_(internal::count_vars(y0_)),
-      args_vars_(internal::count_vars(args...)),
-      coupled_ode_(f, y0, args..., msgs),
-      coupled_state_(coupled_ode_.initial_state()) {
+ public:
+  cvodes_integrator(const F& f, const std::vector<T_initial>& y0,
+                    const T_t0& t0, const std::vector<T_ts>& ts,
+                    const T_Args&... args, std::ostream* msgs,
+                    double relative_tolerance, double absolute_tolerance,
+                    long int max_num_steps)
+      : f_(f),
+        y0_(y0),
+        t0_(t0),
+        ts_(ts),
+        args_tuple_(args...),
+        N_(y0.size()),
+        msgs_(msgs),
+        relative_tolerance_(relative_tolerance),
+        absolute_tolerance_(absolute_tolerance),
+        max_num_steps_(max_num_steps),
+        y0_vars_(internal::count_vars(y0_)),
+        args_vars_(internal::count_vars(args...)),
+        coupled_ode_(f, y0, args..., msgs),
+        coupled_state_(coupled_ode_.initial_state()) {
     using initial_var = stan::is_var<T_initial>;
 
     const char* fun = "cvodes_integrator::integrate";
@@ -76,10 +76,14 @@ class cvodes_integrator {
     check_finite(fun, "initial time", t0_);
     check_finite(fun, "times", ts_);
 
-    // Code from: https://stackoverflow.com/a/17340003 . Should probably do something better
-    apply([&](auto&&... args) {
-	std::vector<int> unused_temp{ 0, (check_finite(fun, "ode parameters and data", args), 0)... };
-      }, args_tuple_);
+    // Code from: https://stackoverflow.com/a/17340003 . Should probably do
+    // something better
+    apply(
+        [&](auto&&... args) {
+          std::vector<int> unused_temp{
+              0, (check_finite(fun, "ode parameters and data", args), 0)...};
+        },
+        args_tuple_);
 
     check_nonzero_size(fun, "times", ts_);
     check_nonzero_size(fun, "initial state", y0_);
@@ -95,7 +99,8 @@ class cvodes_integrator {
     LS_ = SUNDenseLinearSolver(nv_state_, A_);
 
     if (y0_vars_ + args_vars_ > 0) {
-      nv_state_sens_ = N_VCloneVectorArrayEmpty_Serial(y0_vars_ + args_vars_, nv_state_);
+      nv_state_sens_
+          = N_VCloneVectorArrayEmpty_Serial(y0_vars_ + args_vars_, nv_state_);
       for (std::size_t i = 0; i < y0_vars_ + args_vars_; i++) {
         NV_DATA_S(nv_state_sens_[i]) = &coupled_state_[N_] + i * N_;
       }
@@ -116,7 +121,8 @@ class cvodes_integrator {
    * ODE RHS passed to CVODES.
    */
   static int cv_rhs(realtype t, N_Vector y, N_Vector ydot, void* user_data) {
-    const cvodes_integrator* integrator = static_cast<const cvodes_integrator*>(user_data);
+    const cvodes_integrator* integrator
+        = static_cast<const cvodes_integrator*>(user_data);
     integrator->rhs(t, NV_DATA_S(y), NV_DATA_S(ydot));
     return 0;
   }
@@ -128,7 +134,8 @@ class cvodes_integrator {
   static int cv_rhs_sens(int Ns, realtype t, N_Vector y, N_Vector ydot,
                          N_Vector* yS, N_Vector* ySdot, void* user_data,
                          N_Vector tmp1, N_Vector tmp2) {
-    const cvodes_integrator* integrator = static_cast<const cvodes_integrator*>(user_data);
+    const cvodes_integrator* integrator
+        = static_cast<const cvodes_integrator*>(user_data);
     integrator->rhs_sens(t, NV_DATA_S(y), yS, ySdot);
     return 0;
   }
@@ -142,7 +149,8 @@ class cvodes_integrator {
   static int cv_jacobian_states(realtype t, N_Vector y, N_Vector fy,
                                 SUNMatrix J, void* user_data, N_Vector tmp1,
                                 N_Vector tmp2, N_Vector tmp3) {
-    const cvodes_integrator* integrator = static_cast<const cvodes_integrator*>(user_data);
+    const cvodes_integrator* integrator
+        = static_cast<const cvodes_integrator*>(user_data);
     integrator->jacobian_states(t, NV_DATA_S(y), J);
     return 0;
   }
@@ -152,9 +160,13 @@ class cvodes_integrator {
    */
   inline void rhs(double t, const double y[], double dy_dt[]) const {
     const std::vector<double> y_vec(y, y + N_);
-    std::vector<double> dy_dt_vec = apply([&](auto&&... args) {
-	return f_.template operator()<double, double, decltype(value_of(args))...>(t, y_vec, value_of(args)..., msgs_);
-      }, args_tuple_);
+    std::vector<double> dy_dt_vec = apply(
+        [&](auto&&... args) {
+          return f_
+              .template operator()<double, double, decltype(value_of(args))...>(
+                  t, y_vec, value_of(args)..., msgs_);
+        },
+        args_tuple_);
     check_size_match("cvodes_ode_data", "dz_dt", dy_dt_vec.size(), "states",
                      N_);
     std::move(dy_dt_vec.begin(), dy_dt_vec.end(), dy_dt);
@@ -171,12 +183,15 @@ class cvodes_integrator {
     start_nested();
     const std::vector<var> y_vec_var(y, y + N_);
     // TODO: This should only be done once on construction
-    auto double_args_tuple = apply([&](auto&&... args) {
-	return std::make_tuple(value_of(args)...);
-      }, args_tuple_);
-    auto ode_jacobian = apply([&](auto&&... args) {
-	return coupled_ode_system<var, double, double, F, decltype(args)...>(f_, y_vec_var, args..., msgs_);
-      }, double_args_tuple);
+    auto double_args_tuple = apply(
+        [&](auto&&... args) { return std::make_tuple(value_of(args)...); },
+        args_tuple_);
+    auto ode_jacobian = apply(
+        [&](auto&&... args) {
+          return coupled_ode_system<var, double, double, F, decltype(args)...>(
+              f_, y_vec_var, args..., msgs_);
+        },
+        double_args_tuple);
     std::vector<double>&& jacobian_y = std::vector<double>(ode_jacobian.size());
     ode_jacobian(ode_jacobian.initial_state(), jacobian_y, t);
     std::move(jacobian_y.begin() + N_, jacobian_y.end(), SM_DATA_D(J));
@@ -254,10 +269,15 @@ class cvodes_integrator {
     std::vector<double> dy0_dt0;
     if (is_var<T_t0>::value) {
       std::vector<double> y0_dbl = value_of(y0_);
-      dy0_dt0 = apply([&](auto&&... args) {
-	  return f_.template operator()<double, double, decltype(value_of(args))...>(value_of(t0_), y0_dbl, value_of(args)..., msgs_);
-	}, args_tuple_);
-      check_size_match("coupled_ode_observer", "dy_dt", dy0_dt0.size(), "states", N_);
+      dy0_dt0 = apply(
+          [&](auto&&... args) {
+            return f_.template
+            operator()<double, double, decltype(value_of(args))...>(
+                value_of(t0_), y0_dbl, value_of(args)..., msgs_);
+          },
+          args_tuple_);
+      check_size_match("coupled_ode_observer", "dy_dt", dy0_dt0.size(),
+                       "states", N_);
     }
 
     void* cvodes_mem = CVodeCreate(Lmm);
@@ -266,13 +286,14 @@ class cvodes_integrator {
     }
 
     try {
-      check_flag_sundials(CVodeInit(cvodes_mem, &cvodes_integrator::cv_rhs, t0_dbl,
-                                    nv_state_),
-                          "CVodeInit");
+      check_flag_sundials(
+          CVodeInit(cvodes_mem, &cvodes_integrator::cv_rhs, t0_dbl, nv_state_),
+          "CVodeInit");
 
       // Assign pointer to this as user data
-      check_flag_sundials(CVodeSetUserData(cvodes_mem, reinterpret_cast<void*>(this)),
-			  "CVodeSetUserData");
+      check_flag_sundials(
+          CVodeSetUserData(cvodes_mem, reinterpret_cast<void*>(this)),
+          "CVodeSetUserData");
 
       cvodes_set_options(cvodes_mem, relative_tolerance_, absolute_tolerance_,
                          max_num_steps_);
@@ -282,15 +303,18 @@ class cvodes_integrator {
       // create matrix object and linear solver object; resource
       // (de-)allocation is handled in the cvodes_ode_data
       check_flag_sundials(CVodeSetLinearSolver(cvodes_mem, LS_, A_),
-			  "CVodeSetLinearSolver");
-      check_flag_sundials(CVodeSetJacFn(cvodes_mem, &cvodes_integrator::cv_jacobian_states),
-			  "CVodeSetJacFn");
+                          "CVodeSetLinearSolver");
+      check_flag_sundials(
+          CVodeSetJacFn(cvodes_mem, &cvodes_integrator::cv_jacobian_states),
+          "CVodeSetJacFn");
 
       // initialize forward sensitivity system of CVODES as needed
       if (y0_vars_ + args_vars_ > 0) {
-        check_flag_sundials(CVodeSensInit(cvodes_mem, static_cast<int>(y0_vars_ + args_vars_), CV_STAGGERED,
-					  &cvodes_integrator::cv_rhs_sens, nv_state_sens_),
-			    "CVodeSensInit");
+        check_flag_sundials(
+            CVodeSensInit(cvodes_mem, static_cast<int>(y0_vars_ + args_vars_),
+                          CV_STAGGERED, &cvodes_integrator::cv_rhs_sens,
+                          nv_state_sens_),
+            "CVodeSensInit");
 
         check_flag_sundials(CVodeSensEEtolerances(cvodes_mem),
                             "CVodeSensEEtolerances");
@@ -299,29 +323,29 @@ class cvodes_integrator {
       double t_init = t0_dbl;
       for (size_t n = 0; n < ts_.size(); ++n) {
         double t_final = ts_dbl[n];
-	
+
         if (t_final != t_init) {
-          check_flag_sundials(CVode(cvodes_mem, t_final, nv_state_,
-                                    &t_init, CV_NORMAL),
-                              "CVode");
+          check_flag_sundials(
+              CVode(cvodes_mem, t_final, nv_state_, &t_init, CV_NORMAL),
+              "CVode");
         }
-	
+
         if (y0_vars_ + args_vars_ > 0) {
-          check_flag_sundials(
-              CVodeGetSens(cvodes_mem, &t_init, nv_state_sens_),
-              "CVodeGetSens");
+          check_flag_sundials(CVodeGetSens(cvodes_mem, &t_init, nv_state_sens_),
+                              "CVodeGetSens");
         }
 
-        //observer(cvodes_data.coupled_state_, t_final);
-	y.emplace_back(coupled_ode_.build_output(dy0_dt0, coupled_state_, t0_, ts_[n]));
+        // observer(cvodes_data.coupled_state_, t_final);
+        y.emplace_back(
+            coupled_ode_.build_output(dy0_dt0, coupled_state_, t0_, ts_[n]));
 
-	t_init = t_final;
+        t_init = t_final;
       }
     } catch (const std::exception& e) {
       CVodeFree(&cvodes_mem);
       throw;
     }
-      
+
     CVodeFree(&cvodes_mem);
 
     return y;
diff --git a/stan/math/rev/functor/integrate_ode_adams.hpp b/stan/math/rev/functor/integrate_ode_adams.hpp
index 5e8820a9408..d6c0d2bca21 100644
--- a/stan/math/rev/functor/integrate_ode_adams.hpp
+++ b/stan/math/rev/functor/integrate_ode_adams.hpp
@@ -21,11 +21,10 @@ integrate_ode_adams(const F& f, const std::vector<T_initial>& y0,
                     double absolute_tolerance = 1e-10,
                     long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
   stan::math::cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts,
-				std::vector<T_param>,
-				std::vector<double>,
-				std::vector<int>> integrator(f, y0, t0, ts, theta, x, x_int, msgs,
-							     relative_tolerance, absolute_tolerance,
-							     max_num_steps);
+                                std::vector<T_param>, std::vector<double>,
+                                std::vector<int>>
+      integrator(f, y0, t0, ts, theta, x, x_int, msgs, relative_tolerance,
+                 absolute_tolerance, max_num_steps);
   return integrator.integrate();
 }
 
diff --git a/stan/math/rev/functor/integrate_ode_bdf.hpp b/stan/math/rev/functor/integrate_ode_bdf.hpp
index a40703de54a..b216b78a5f9 100644
--- a/stan/math/rev/functor/integrate_ode_bdf.hpp
+++ b/stan/math/rev/functor/integrate_ode_bdf.hpp
@@ -21,11 +21,10 @@ integrate_ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
                   double absolute_tolerance = 1e-10,
                   long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
   stan::math::cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts,
-				std::vector<T_param>,
-				std::vector<double>,
-				std::vector<int>> integrator(f, y0, t0, ts, theta, x, x_int, msgs,
-							     relative_tolerance, absolute_tolerance,
-							     max_num_steps);
+                                std::vector<T_param>, std::vector<double>,
+                                std::vector<int>>
+      integrator(f, y0, t0, ts, theta, x, x_int, msgs, relative_tolerance,
+                 absolute_tolerance, max_num_steps);
   return integrator.integrate();
 }
 
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 2e2cac6060f..39711c2cec5 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -9,21 +9,17 @@
 namespace stan {
 namespace math {
 
-template <typename F, typename T_initial, typename T_t0, typename T_ts, typename... T_Args>
-std::vector<std::vector<typename stan::return_type<T_initial, T_t0, T_ts, T_Args...>::type>>
+template <typename F, typename T_initial, typename T_t0, typename T_ts,
+          typename... T_Args>
+std::vector<std::vector<
+    typename stan::return_type<T_initial, T_t0, T_ts, T_Args...>::type>>
 ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
-	const std::vector<T_ts>& ts,
-	double relative_tolerance,
-	double absolute_tolerance,
-	long int max_num_steps,
-	std::ostream* msgs,
-	const T_Args&... args) {  // NOLINT(runtime/int)
+        const std::vector<T_ts>& ts, double relative_tolerance,
+        double absolute_tolerance, long int max_num_steps, std::ostream* msgs,
+        const T_Args&... args) {  // NOLINT(runtime/int)
   stan::math::cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...>
-    integrator(f, y0, t0, ts,
-	       args...,
-	       msgs,
-	       relative_tolerance, absolute_tolerance,
-	       max_num_steps);
+  integrator(f, y0, t0, ts, args..., msgs, relative_tolerance,
+             absolute_tolerance, max_num_steps);
   return integrator.integrate();
 }
 
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index 80e3a532cb5..423ab3e257d 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -29,35 +29,35 @@ auto sum_(Vec&& arg) {
 
 struct CosArg1 {
   template <typename T0, typename T1, typename... T_Args>
-  inline std::vector<stan::return_type_t<T1, T_Args...>>
-  operator()(const T0& t, const std::vector<T1>& y,
-	     const T_Args&... a, std::ostream* msgs) const {
-
-    std::vector<typename stan::return_type<T0, T_Args...>::type> vec = { sum_(a)... };
-    return { stan::math::cos(sum_(vec) * t) };
+  inline std::vector<stan::return_type_t<T1, T_Args...>> operator()(
+      const T0& t, const std::vector<T1>& y, const T_Args&... a,
+      std::ostream* msgs) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    return {stan::math::cos(sum_(vec) * t)};
   }
 };
 
 struct Cos2Arg {
   template <typename T0, typename T1, typename T2, typename T3>
-  inline std::vector<typename stan::return_type<T1, T2, T3>::type>
-  operator()(const T0& t, const std::vector<T1>& y,
-	     const T2& a, const T3& b, std::ostream* msgs) const {
-    
-    return { stan::math::cos((sum_(a) + sum_(b)) * t) };
+  inline std::vector<typename stan::return_type<T1, T2, T3>::type> operator()(
+      const T0& t, const std::vector<T1>& y, const T2& a, const T3& b,
+      std::ostream* msgs) const {
+    return {stan::math::cos((sum_(a) + sum_(b)) * t)};
   }
 };
 
 TEST(StanMathOde_ode_bdf, t0) {
   using stan::math::var;
-  
-  std::vector<double> y0 = { 0.0 };
+
+  std::vector<double> y0 = {0.0};
   var t0 = 0.0;
-  std::vector<double> ts = { 0.45, 1.1 };
+  std::vector<double> ts = {0.45, 1.1};
 
   double a = 1.5;
-  
-  std::vector<std::vector<var>> output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
+
+  std::vector<std::vector<var>> output = stan::math::ode_bdf(
+      CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
 
   output[0][0].grad();
 
@@ -74,14 +74,15 @@ TEST(StanMathOde_ode_bdf, t0) {
 
 TEST(StanMathOde_ode_bdf, ts) {
   using stan::math::var;
-  
-  std::vector<double> y0 = { 0.0 };
+
+  std::vector<double> y0 = {0.0};
   double t0 = 0.0;
-  std::vector<var> ts = { 0.45, 1.1 };
+  std::vector<var> ts = {0.45, 1.1};
 
   double a = 1.5;
-  
-  std::vector<std::vector<var>> output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
+
+  std::vector<std::vector<var>> output = stan::math::ode_bdf(
+      CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
 
   output[0][0].grad();
 
@@ -91,21 +92,22 @@ TEST(StanMathOde_ode_bdf, ts) {
   stan::math::set_zero_all_adjoints();
 
   output[1][0].grad();
-  
+
   EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
   EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
 }
 
 TEST(StanMathOde_ode_bdf, scalar_arg) {
   using stan::math::var;
-  
-  std::vector<double> y0 = { 0.0 };
+
+  std::vector<double> y0 = {0.0};
   double t0 = 0.0;
-  std::vector<double> ts = { 1.1 };
+  std::vector<double> ts = {1.1};
 
   var a = 1.5;
-  
-  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                   nullptr, a)[0][0];
 
   output.grad();
 
@@ -115,14 +117,15 @@ TEST(StanMathOde_ode_bdf, scalar_arg) {
 
 TEST(StanMathOde_ode_bdf, std_vector_arg) {
   using stan::math::var;
-  
-  std::vector<double> y0 = { 0.0 };
+
+  std::vector<double> y0 = {0.0};
   double t0 = 0.0;
-  std::vector<double> ts = { 1.1 };
+  std::vector<double> ts = {1.1};
 
-  std::vector<var> a = { 1.5 };
-  
-  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+  std::vector<var> a = {1.5};
+
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                   nullptr, a)[0][0];
 
   output.grad();
 
@@ -132,15 +135,16 @@ TEST(StanMathOde_ode_bdf, std_vector_arg) {
 
 TEST(StanMathOde_ode_bdf, vector_arg) {
   using stan::math::var;
-  
-  std::vector<double> y0 = { 0.0 };
+
+  std::vector<double> y0 = {0.0};
   double t0 = 0.0;
-  std::vector<double> ts = { 1.1 };
+  std::vector<double> ts = {1.1};
 
   Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
   a << 1.5;
-  
-  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                   nullptr, a)[0][0];
 
   output.grad();
 
@@ -150,15 +154,16 @@ TEST(StanMathOde_ode_bdf, vector_arg) {
 
 TEST(StanMathOde_ode_bdf, row_vector_arg) {
   using stan::math::var;
-  
-  std::vector<double> y0 = { 0.0 };
+
+  std::vector<double> y0 = {0.0};
   double t0 = 0.0;
-  std::vector<double> ts = { 1.1 };
+  std::vector<double> ts = {1.1};
 
   Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
   a << 1.5;
-  
-  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                   nullptr, a)[0][0];
 
   output.grad();
 
@@ -168,15 +173,16 @@ TEST(StanMathOde_ode_bdf, row_vector_arg) {
 
 TEST(StanMathOde_ode_bdf, matrix_arg) {
   using stan::math::var;
-  
-  std::vector<double> y0 = { 0.0 };
+
+  std::vector<double> y0 = {0.0};
   double t0 = 0.0;
-  std::vector<double> ts = { 1.1 };
+  std::vector<double> ts = {1.1};
 
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
   a << 1.5;
-  
-  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                   nullptr, a)[0][0];
 
   output.grad();
 
@@ -186,16 +192,16 @@ TEST(StanMathOde_ode_bdf, matrix_arg) {
 
 TEST(StanMathOde_ode_bdf, scalar_std_vector_args) {
   using stan::math::var;
-  
-  std::vector<double> y0 = { 0.0 };
+
+  std::vector<double> y0 = {0.0};
   double t0 = 0.0;
-  std::vector<double> ts = { 1.1 };
+  std::vector<double> ts = {1.1};
 
   var a0 = 0.0;
-  std::vector<var> a1 = { 1.5 };
-  
-  var output = stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr,
-				   a0, a1)[0][0];
+  std::vector<var> a1 = {1.5};
+
+  var output = stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                   nullptr, a0, a1)[0][0];
 
   output.grad();
 

From 12f6ad9b264ba7f9b9adba1f79549c299a5225e0 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Fri, 3 Apr 2020 15:49:14 -0400
Subject: [PATCH 101/189] Changed order of arguments for all the ODE stuff so
 the variadic arguments go last

---
 stan/math/prim/functor/coupled_ode_system.hpp    |  9 +++++----
 stan/math/rev/functor/coupled_ode_system.hpp     |  7 ++++---
 stan/math/rev/functor/cvodes_integrator.hpp      | 14 +++++++-------
 stan/math/rev/functor/ode_bdf.hpp                |  6 +++---
 test/unit/math/rev/functor/ode_bdf_prim_test.cpp |  4 ++--
 5 files changed, 21 insertions(+), 19 deletions(-)

diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
index e9de342fe6d..59266926af6 100644
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -84,7 +84,7 @@ struct coupled_ode_system_impl<true, T_initial, T_t0, T_ts, F, Args...> {
    * @param[in, out] msgs stream for messages
    */
   coupled_ode_system_impl(const F& f, const std::vector<double>& y0,
-			  const Args&... args, std::ostream* msgs)
+			  std::ostream* msgs, const Args&... args)
       : f_(f),
         y0_(y0),
 	args_tuple_(args...),
@@ -95,7 +95,7 @@ struct coupled_ode_system_impl<true, T_initial, T_t0, T_ts, F, Args...> {
   void operator()(const std::vector<double>& y, std::vector<double>& dy_dt,
                   double t) const {
     dy_dt = apply([&](const Args&... args) {
-	return f_.template operator()<double, double, Args...>(t, y, args..., msgs_);
+	return f_(t, y, msgs_, args...);
       }, args_tuple_);
 
     check_size_match("coupled_ode_system", "y", y.size(), "dy_dt",
@@ -143,10 +143,11 @@ template <typename T_initial, typename T_t0, typename T_ts, typename F, typename
 struct coupled_ode_system :
     public coupled_ode_system_impl<std::is_arithmetic<return_type_t<T_initial, T_t0, T_ts, Args...>>::value,
 				   T_initial, T_t0, T_ts, F, Args...> {
+
   coupled_ode_system(const F& f, const std::vector<T_initial>& y0,
-		     const Args&... args, std::ostream* msgs)
+		     std::ostream* msgs, const Args&... args)
     : coupled_ode_system_impl<std::is_arithmetic<return_type_t<T_initial, T_t0, T_ts, Args...>>::value,
-			      T_initial, T_t0, T_ts, F, Args...>(f, y0, args..., msgs) {}
+			      T_initial, T_t0, T_ts, F, Args...>(f, y0, msgs, args...) {}
 };
 
 }  // namespace math
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index 3909ecbec5e..515fdcaf322 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -87,7 +87,8 @@ struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
    * @param[in, out] msgs stream for messages
    */
   coupled_ode_system_impl(const F& f, const std::vector<T_initial>& y0,
-			  const Args&... args, std::ostream* msgs)
+			  std::ostream* msgs,
+			  const Args&... args)
       : f_(f),
         y0_(y0),
         args_tuple_(args...),
@@ -126,7 +127,7 @@ struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
 				  args_tuple_);
     
     vector<var> dy_dt_vars = apply(
-				   [&](auto&&... args) { return f_.template operator()<double, var, decltype(args)...>(t, y_vars, args..., msgs_); },
+				   [&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
 				   local_args_tuple);
 
     check_size_match("coupled_ode_system", "dz_dt", dy_dt_vars.size(), "states",
@@ -182,7 +183,7 @@ struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
 	  return f_(t, y_vars, args..., msgs_);
 	  }, local_args_tuple);*/
       dy_dt = apply([&](auto&&... args) {
-	  return f_.template operator()<double, double, decltype(value_of(args))...>(value_of(t), y_dbl, value_of(args)..., msgs_);
+	  return f_(value_of(t), y_dbl, msgs_, value_of(args)...);
 	}, args_tuple_);
       check_size_match("coupled_ode_observer", "dy_dt", dy_dt.size(), "states", N_);
     }
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 0f195ce1079..57bcf77c8ca 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -50,10 +50,10 @@ class cvodes_integrator {
 
 public:
   cvodes_integrator(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
-		    const std::vector<T_ts>& ts, const T_Args&... args,
-		    std::ostream* msgs, double relative_tolerance,
+		    const std::vector<T_ts>& ts, double relative_tolerance,
 		    double absolute_tolerance,
-		    long int max_num_steps)
+		    long int max_num_steps,
+		    std::ostream* msgs, const T_Args&... args)
     : f_(f),
       y0_(y0),
       t0_(t0),
@@ -66,7 +66,7 @@ class cvodes_integrator {
       max_num_steps_(max_num_steps),
       y0_vars_(internal::count_vars(y0_)),
       args_vars_(internal::count_vars(args...)),
-      coupled_ode_(f, y0, args..., msgs),
+      coupled_ode_(f, y0, msgs, args...),
       coupled_state_(coupled_ode_.initial_state()) {
     using initial_var = stan::is_var<T_initial>;
 
@@ -153,7 +153,7 @@ class cvodes_integrator {
   inline void rhs(double t, const double y[], double dy_dt[]) const {
     const std::vector<double> y_vec(y, y + N_);
     std::vector<double> dy_dt_vec = apply([&](auto&&... args) {
-	return f_.template operator()<double, double, decltype(value_of(args))...>(t, y_vec, value_of(args)..., msgs_);
+	return f_(t, y_vec, msgs_, value_of(args)...);
       }, args_tuple_);
     check_size_match("cvodes_ode_data", "dz_dt", dy_dt_vec.size(), "states",
                      N_);
@@ -175,7 +175,7 @@ class cvodes_integrator {
 	return std::make_tuple(value_of(args)...);
       }, args_tuple_);
     auto ode_jacobian = apply([&](auto&&... args) {
-	return coupled_ode_system<var, double, double, F, decltype(args)...>(f_, y_vec_var, args..., msgs_);
+	return coupled_ode_system<var, double, double, F, decltype(args)...>(f_, y_vec_var, msgs_, args...);
       }, double_args_tuple);
     std::vector<double>&& jacobian_y = std::vector<double>(ode_jacobian.size());
     ode_jacobian(ode_jacobian.initial_state(), jacobian_y, t);
@@ -255,7 +255,7 @@ class cvodes_integrator {
     if (is_var<T_t0>::value) {
       std::vector<double> y0_dbl = value_of(y0_);
       dy0_dt0 = apply([&](auto&&... args) {
-	  return f_.template operator()<double, double, decltype(value_of(args))...>(value_of(t0_), y0_dbl, value_of(args)..., msgs_);
+	  return f_(value_of(t0_), y0_dbl, msgs_, value_of(args)...);
 	}, args_tuple_);
       check_size_match("coupled_ode_observer", "dy_dt", dy0_dt0.size(), "states", N_);
     }
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 2e2cac6060f..d50322068ce 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -20,10 +20,10 @@ ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
 	const T_Args&... args) {  // NOLINT(runtime/int)
   stan::math::cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...>
     integrator(f, y0, t0, ts,
-	       args...,
-	       msgs,
 	       relative_tolerance, absolute_tolerance,
-	       max_num_steps);
+	       max_num_steps,
+	       msgs,
+	       args...);
   return integrator.integrate();
 }
 
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index 80e3a532cb5..431726e5a3e 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -31,7 +31,7 @@ struct CosArg1 {
   template <typename T0, typename T1, typename... T_Args>
   inline std::vector<stan::return_type_t<T1, T_Args...>>
   operator()(const T0& t, const std::vector<T1>& y,
-	     const T_Args&... a, std::ostream* msgs) const {
+	     std::ostream* msgs, const T_Args&... a) const {
 
     std::vector<typename stan::return_type<T0, T_Args...>::type> vec = { sum_(a)... };
     return { stan::math::cos(sum_(vec) * t) };
@@ -42,7 +42,7 @@ struct Cos2Arg {
   template <typename T0, typename T1, typename T2, typename T3>
   inline std::vector<typename stan::return_type<T1, T2, T3>::type>
   operator()(const T0& t, const std::vector<T1>& y,
-	     const T2& a, const T3& b, std::ostream* msgs) const {
+	      std::ostream* msgs, const T2& a, const T3& b) const {
     
     return { stan::math::cos((sum_(a) + sum_(b)) * t) };
   }

From 64a017e9e2eb7eda7436c9194024047c813c5bdc Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 13 Apr 2020 09:45:33 -0400
Subject: [PATCH 102/189] Variadic versions of ode solvers named ode_bdf and
 ode_rk45 Versions with tolerances are ode_bdf_tol and ode_rk45_tol

ODE rhs functions take variadic arguments last, which means the std::ostream msgs pointer comes before them.

Updated existing bdf/rk45 tests to correctly test t0 gradients

Pointed old integrate_ode_rk45 and integrate_ode_bdf functions at new implementations (so they're simply wrappers now)

Moved code that handles time gradients into its own set of functions (ode_add_time_gradients.hpp)

Moved code that packs coupled system sensitivities into Stan autodiff variables into its own function (ode_store_sensitivities)
---
 stan/math/prim/fun.hpp                        |   1 +
 .../math/prim/fun/ode_store_sensitivities.hpp |  20 ++
 stan/math/prim/functor.hpp                    |   1 +
 stan/math/prim/functor/coupled_ode_system.hpp |  23 +-
 stan/math/prim/functor/integrate_ode_rk45.hpp |  99 +--------
 stan/math/prim/functor/ode_rk45.hpp           | 118 ++++++++++
 stan/math/rev/fun.hpp                         |   2 +-
 stan/math/rev/fun/ode_store_sensitivities.hpp |  56 +++++
 stan/math/rev/functor.hpp                     |   2 +
 stan/math/rev/functor/coupled_ode_rhs.hpp     |  75 +++++++
 stan/math/rev/functor/coupled_ode_system.hpp  | 105 ++-------
 stan/math/rev/functor/cvodes_integrator.hpp   | 195 +++++++++--------
 stan/math/rev/functor/integrate_ode_bdf.hpp   |  15 +-
 .../rev/functor/ode_add_time_gradients.hpp    |  75 +++++++
 stan/math/rev/functor/ode_bdf.hpp             |  39 +++-
 stan/math/rev/functor/ode_rk45.hpp            |  50 +++++
 .../functor/forced_harmonic_oscillator.hpp    |   3 +-
 .../math/prim/functor/harmonic_oscillator.hpp |  12 +-
 .../functor/integrate_ode_rk45_prim_test.cpp  | 176 ++++-----------
 test/unit/math/prim/functor/lorenz.hpp        |   3 +-
 .../functor/integrate_ode_bdf_prim_test.cpp   |   2 +-
 .../functor/integrate_ode_bdf_rev_test.cpp    |  15 +-
 .../functor/integrate_ode_rk45_rev_test.cpp   |  67 +++---
 .../math/rev/functor/ode_bdf_prim_test.cpp    |  32 +--
 .../math/rev/functor/ode_rk45_prim_test.cpp   | 204 ++++++++++++++++++
 test/unit/math/rev/functor/util.hpp           | 141 ++++--------
 26 files changed, 926 insertions(+), 605 deletions(-)
 create mode 100644 stan/math/prim/fun/ode_store_sensitivities.hpp
 create mode 100644 stan/math/prim/functor/ode_rk45.hpp
 create mode 100644 stan/math/rev/fun/ode_store_sensitivities.hpp
 create mode 100644 stan/math/rev/functor/coupled_ode_rhs.hpp
 create mode 100644 stan/math/rev/functor/ode_add_time_gradients.hpp
 create mode 100644 stan/math/rev/functor/ode_rk45.hpp
 create mode 100644 test/unit/math/rev/functor/ode_rk45_prim_test.cpp

diff --git a/stan/math/prim/fun.hpp b/stan/math/prim/fun.hpp
index f214acd63ea..8bb41e2271c 100644
--- a/stan/math/prim/fun.hpp
+++ b/stan/math/prim/fun.hpp
@@ -211,6 +211,7 @@
 #include <stan/math/prim/fun/multiply_lower_tri_self_transpose.hpp>
 #include <stan/math/prim/fun/norm.hpp>
 #include <stan/math/prim/fun/num_elements.hpp>
+#include <stan/math/prim/fun/ode_store_sensitivities.hpp>
 #include <stan/math/prim/fun/offset_multiplier_constrain.hpp>
 #include <stan/math/prim/fun/offset_multiplier_free.hpp>
 #include <stan/math/prim/fun/one_hot_array.hpp>
diff --git a/stan/math/prim/fun/ode_store_sensitivities.hpp b/stan/math/prim/fun/ode_store_sensitivities.hpp
new file mode 100644
index 00000000000..5c2e6599db3
--- /dev/null
+++ b/stan/math/prim/fun/ode_store_sensitivities.hpp
@@ -0,0 +1,20 @@
+#ifndef STAN_MATH_PRIM_FUN_ODE_STORE_SENSITIVITIES_HPP
+#define STAN_MATH_PRIM_FUN_ODE_STORE_SENSITIVITIES_HPP
+
+#include <stan/math/prim/meta.hpp>
+#include <ostream>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+template <typename... Args, typename = require_all_arithmetic_t<scalar_type_t<Args>...>>
+std::vector<double> ode_store_sensitivities(const std::vector<double>& coupled_state,
+					    const std::vector<double>& y0,
+					    const Args&... args) {
+  return std::vector<double>(coupled_state.data(), coupled_state.data() + y0.size());
+}
+
+}  // namespace math
+}  // namespace stan
+#endif
diff --git a/stan/math/prim/functor.hpp b/stan/math/prim/functor.hpp
index 7ca08d66260..6e88791d26c 100644
--- a/stan/math/prim/functor.hpp
+++ b/stan/math/prim/functor.hpp
@@ -10,6 +10,7 @@
 #include <stan/math/prim/functor/finite_diff_hessian_helper.hpp>
 #include <stan/math/prim/functor/integrate_1d.hpp>
 #include <stan/math/prim/functor/integrate_ode_rk45.hpp>
+#include <stan/math/prim/functor/ode_rk45.hpp>
 #include <stan/math/prim/functor/left_fold.hpp>
 #include <stan/math/prim/functor/map_rect.hpp>
 #include <stan/math/prim/functor/map_rect_combine.hpp>
diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
index 59266926af6..4885bf3f3b4 100644
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -60,11 +60,11 @@ namespace math {
  * msgs)</code>
  */
 
-template <bool Enable, typename T_initial, typename T_t0, typename T_ts, typename F, typename... Args>
+template <bool Enable, typename F, typename T_initial, typename... Args>
 struct coupled_ode_system_impl;
   
-template <typename T_initial, typename T_t0, typename T_ts, typename F, typename... Args>
-struct coupled_ode_system_impl<true, T_initial, T_t0, T_ts, F, Args...> {
+template <typename F, typename T_initial, typename... Args>
+struct coupled_ode_system_impl<true, F, T_initial, Args...> {
   const F& f_;
   const std::vector<double>& y0_;
   std::tuple<const Args&...> args_tuple_;
@@ -102,13 +102,6 @@ struct coupled_ode_system_impl<true, T_initial, T_t0, T_ts, F, Args...> {
                      dy_dt.size());
   }
 
-  std::vector<double> build_output(const std::vector<double>& dy0_dt0,
-				   const std::vector<double>& coupled_state,
-				   const double& t0,
-				   const double& t) const {
-    return std::vector<double>(coupled_state.data(), coupled_state.data() + N_);
-  }
-
   /**
    * Returns the size of the coupled system.
    *
@@ -139,15 +132,15 @@ struct coupled_ode_system_impl<true, T_initial, T_t0, T_ts, F, Args...> {
   }
 };
 
-template <typename T_initial, typename T_t0, typename T_ts, typename F, typename... Args>
+template <typename F, typename T_initial, typename... Args>
 struct coupled_ode_system :
-    public coupled_ode_system_impl<std::is_arithmetic<return_type_t<T_initial, T_t0, T_ts, Args...>>::value,
-				   T_initial, T_t0, T_ts, F, Args...> {
+    public coupled_ode_system_impl<std::is_arithmetic<return_type_t<T_initial, Args...>>::value,
+				   F, T_initial, Args...> {
 
   coupled_ode_system(const F& f, const std::vector<T_initial>& y0,
 		     std::ostream* msgs, const Args&... args)
-    : coupled_ode_system_impl<std::is_arithmetic<return_type_t<T_initial, T_t0, T_ts, Args...>>::value,
-			      T_initial, T_t0, T_ts, F, Args...>(f, y0, msgs, args...) {}
+    : coupled_ode_system_impl<std::is_arithmetic<return_type_t<T_initial, Args...>>::value,
+			      F, T_initial, Args...>(f, y0, msgs, args...) {}
 };
 
 }  // namespace math
diff --git a/stan/math/prim/functor/integrate_ode_rk45.hpp b/stan/math/prim/functor/integrate_ode_rk45.hpp
index 37a42113ef7..dbecf93832a 100644
--- a/stan/math/prim/functor/integrate_ode_rk45.hpp
+++ b/stan/math/prim/functor/integrate_ode_rk45.hpp
@@ -2,19 +2,8 @@
 #define STAN_MATH_PRIM_FUNCTOR_INTEGRATE_ODE_RK45_HPP
 
 #include <stan/math/prim/meta.hpp>
-#include <stan/math/prim/err.hpp>
-#include <stan/math/prim/functor/coupled_ode_system.hpp>
-#include <stan/math/prim/fun/value_of.hpp>
-#include <stan/math/prim/functor/apply.hpp>
-#include <boost/version.hpp>
-#if BOOST_VERSION == 106400
-#include <boost/serialization/array_wrapper.hpp>
-#endif
-#include <boost/numeric/odeint.hpp>
-#include <algorithm>
+#include <stan/math/prim/functor/ode_rk45.hpp>
 #include <ostream>
-#include <functional>
-#include <iterator>
 #include <vector>
 
 namespace stan {
@@ -67,89 +56,21 @@ namespace math {
  * same size as the state variable, corresponding to a time in ts.
  */
 
-template <typename... Args, typename F, typename T1, typename T_t0, typename T_ts>
-std::vector<std::vector<return_type_t<T1, T_t0, T_ts, Args...>>> integrate_ode_rk45(
+template <typename F, typename T1, typename T_param, typename T_t0, typename T_ts>
+std::vector<std::vector<return_type_t<T1, T_t0, T_ts, T_param>>> integrate_ode_rk45(
     const F& f, const std::vector<T1>& y0, const T_t0& t0,
     const std::vector<T_ts>& ts,
-    const Args&... args,
+    const std::vector<T_param>& theta,
+    const std::vector<double>& x, const std::vector<int>& x_int,
     std::ostream* msgs = nullptr,
     double relative_tolerance = 1e-6,
     double absolute_tolerance = 1e-6,
     int max_num_steps = 1e6) {
-  using boost::numeric::odeint::integrate_times;
-  using boost::numeric::odeint::make_dense_output;
-  using boost::numeric::odeint::max_step_checker;
-  using boost::numeric::odeint::runge_kutta_dopri5;
-
-  const double t0_dbl = value_of(t0);
-  const std::vector<double> ts_dbl = value_of(ts);
-
-  check_finite("integrate_ode_rk45", "initial state", y0);
-  check_finite("integrate_ode_rk45", "initial time", t0_dbl);
-  check_finite("integrate_ode_rk45", "times", ts_dbl);
-
-  // Code from: https://stackoverflow.com/a/17340003 . Should probably do
-  // something better
-  std::vector<int> unused_temp{
-      0, (check_finite("integrate_ode_rk45", "ode parameters and data", args),
-          0)...};
-
-  check_nonzero_size("integrate_ode_rk45", "initial state", y0);
-  check_nonzero_size("integrate_ode_rk45", "times", ts_dbl);
-  check_ordered("integrate_ode_rk45", "times", ts_dbl);
-  check_less("integrate_ode_rk45", "initial time", t0_dbl, ts_dbl[0]);
-
-  if (relative_tolerance <= 0) {
-    invalid_argument("integrate_ode_rk45", "relative_tolerance,",
-                     relative_tolerance, "", ", must be greater than 0");
-  }
-  if (absolute_tolerance <= 0) {
-    invalid_argument("integrate_ode_rk45", "absolute_tolerance,",
-                     absolute_tolerance, "", ", must be greater than 0");
-  }
-  if (max_num_steps <= 0) {
-    invalid_argument("integrate_ode_rk45", "max_num_steps,", max_num_steps, "",
-                     ", must be greater than 0");
-  }
-
-  using return_t = return_type_t<T1, T_t0, T_ts, Args...>;
-  // creates basic or coupled system by template specializations
-  coupled_ode_system<T1, T_t0, T_ts, F, Args...> coupled_system(f, y0, args..., msgs);
-
-  // first time in the vector must be time of initial state
-  std::vector<double> ts_vec(ts.size() + 1);
-  ts_vec[0] = t0_dbl;
-  std::copy(ts_dbl.begin(), ts_dbl.end(), ts_vec.begin() + 1);
-
-  std::vector<std::vector<return_t>> y;
-  bool observer_initial_recorded = false;
-  size_t time_index = 0;
-  
-  // avoid recording of the initial state which is included by the
-  // conventions of odeint in the output
-  auto filtered_observer
-      = [&](const std::vector<double>& coupled_state, double t) -> void {
-    if (!observer_initial_recorded) {
-      observer_initial_recorded = true;
-      return;
-    }
-    y.emplace_back(coupled_system.build_output(coupled_state, ts[time_index]));
-    time_index++;
-  };
-
-  // the coupled system creates the coupled initial state
-  std::vector<double> initial_coupled_state = coupled_system.initial_state();
-
-  const double step_size = 0.1;
-  integrate_times(
-      make_dense_output(absolute_tolerance, relative_tolerance,
-                        runge_kutta_dopri5<std::vector<double>, double,
-                                           std::vector<double>, double>()),
-      std::ref(coupled_system), initial_coupled_state, std::begin(ts_vec),
-      std::end(ts_vec), step_size, filtered_observer,
-      max_step_checker(max_num_steps));
-
-  return y;
+  return ode_rk45_tol(f, y0, t0, ts,
+		      relative_tolerance, absolute_tolerance,
+		      max_num_steps,
+		      msgs,
+		      theta, x, x_int);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
new file mode 100644
index 00000000000..173bcd09438
--- /dev/null
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -0,0 +1,118 @@
+#ifndef STAN_MATH_PRIM_FUNCTOR_ODE_RK45_HPP
+#define STAN_MATH_PRIM_FUNCTOR_ODE_RK45_HPP
+
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/functor/coupled_ode_system.hpp>
+#include <stan/math/prim/fun/ode_store_sensitivities.hpp>
+#include <boost/numeric/odeint.hpp>
+#include <ostream>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+template <typename F, typename T_initial, typename... Args>
+std::vector<std::vector<typename stan::return_type<T_initial, Args...>::type>>
+ode_rk45(const F& f, const std::vector<T_initial>& y0,
+	 double t0,
+	 const std::vector<double>& ts,
+	 std::ostream* msgs,
+	 const Args&... args) {
+  double relative_tolerance = 1e-6;
+  double absolute_tolerance = 1e-6;
+  long int max_num_steps = 1e6;
+
+  return ode_rk45_tol(f, y0, t0, ts,
+		      relative_tolerance, absolute_tolerance,
+		      max_num_steps,
+		      msgs,
+		      args...);
+}
+
+template <typename F, typename T_initial, typename... Args>
+std::vector<std::vector<typename stan::return_type<T_initial, Args...>::type>>
+ode_rk45_tol(const F& f, const std::vector<T_initial>& y0,
+	     double t0,
+	     const std::vector<double>& ts,
+	     double relative_tolerance,
+	     double absolute_tolerance,
+	     long int max_num_steps,
+	     std::ostream* msgs,
+	     const Args&... args) {
+  using boost::numeric::odeint::integrate_times;
+  using boost::numeric::odeint::make_dense_output;
+  using boost::numeric::odeint::max_step_checker;
+  using boost::numeric::odeint::runge_kutta_dopri5;
+
+  const std::vector<double> ts_dbl = value_of(ts);
+
+  check_finite("integrate_ode_rk45", "initial state", y0);
+  check_finite("integrate_ode_rk45", "initial time", t0);
+  check_finite("integrate_ode_rk45", "times", ts_dbl);
+
+  // Code from https://stackoverflow.com/a/17340003
+  std::vector<int> unused_temp{
+      0, (check_finite("integrate_ode_rk45", "ode parameters and data", args),
+          0)...};
+
+  check_nonzero_size("integrate_ode_rk45", "initial state", y0);
+  check_nonzero_size("integrate_ode_rk45", "times", ts_dbl);
+  check_ordered("integrate_ode_rk45", "times", ts_dbl);
+  check_less("integrate_ode_rk45", "initial time", t0, ts_dbl[0]);
+
+  if (relative_tolerance <= 0) {
+    invalid_argument("integrate_ode_rk45", "relative_tolerance,",
+                     relative_tolerance, "", ", must be greater than 0");
+  }
+  if (absolute_tolerance <= 0) {
+    invalid_argument("integrate_ode_rk45", "absolute_tolerance,",
+                     absolute_tolerance, "", ", must be greater than 0");
+  }
+  if (max_num_steps <= 0) {
+    invalid_argument("integrate_ode_rk45", "max_num_steps,", max_num_steps, "",
+                     ", must be greater than 0");
+  }
+
+  using return_t = return_type_t<T_initial, Args...>;
+  // creates basic or coupled system by template specializations
+  coupled_ode_system<F, T_initial, Args...> coupled_system(f, y0, msgs, args...);
+
+  // first time in the vector must be time of initial state
+  std::vector<double> ts_vec(ts.size() + 1);
+  ts_vec[0] = t0;
+  std::copy(ts_dbl.begin(), ts_dbl.end(), ts_vec.begin() + 1);
+
+  std::vector<std::vector<return_t>> y;
+  bool observer_initial_recorded = false;
+  size_t time_index = 0;
+  
+  // avoid recording of the initial state which is included by the
+  // conventions of odeint in the output
+  auto filtered_observer
+      = [&](const std::vector<double>& coupled_state, double t) -> void {
+    if (!observer_initial_recorded) {
+      observer_initial_recorded = true;
+      return;
+    }
+    y.emplace_back(ode_store_sensitivities(coupled_state, y0, args...));
+    time_index++;
+  };
+
+  // the coupled system creates the coupled initial state
+  std::vector<double> initial_coupled_state = coupled_system.initial_state();
+
+  const double step_size = 0.1;
+  integrate_times(
+      make_dense_output(absolute_tolerance, relative_tolerance,
+                        runge_kutta_dopri5<std::vector<double>, double,
+                                           std::vector<double>, double>()),
+      std::ref(coupled_system), initial_coupled_state, std::begin(ts_vec),
+      std::end(ts_vec), step_size, filtered_observer,
+      max_step_checker(max_num_steps));
+
+  return y;
+}
+
+}  // namespace math
+}  // namespace stan
+#endif
diff --git a/stan/math/rev/fun.hpp b/stan/math/rev/fun.hpp
index 72fab2ba736..9436ec452f0 100644
--- a/stan/math/rev/fun.hpp
+++ b/stan/math/rev/fun.hpp
@@ -32,7 +32,6 @@
 #include <stan/math/rev/fun/conj.hpp>
 #include <stan/math/rev/fun/cos.hpp>
 #include <stan/math/rev/fun/cosh.hpp>
-#include <stan/math/rev/fun/count_vars.hpp>
 #include <stan/math/rev/fun/cov_exp_quad.hpp>
 #include <stan/math/rev/fun/determinant.hpp>
 #include <stan/math/rev/fun/digamma.hpp>
@@ -107,6 +106,7 @@
 #include <stan/math/rev/fun/multiply_log.hpp>
 #include <stan/math/rev/fun/multiply_lower_tri_self_transpose.hpp>
 #include <stan/math/rev/fun/norm.hpp>
+#include <stan/math/rev/fun/ode_store_sensitivities.hpp>
 #include <stan/math/rev/fun/ordered_constrain.hpp>
 #include <stan/math/rev/fun/owens_t.hpp>
 #include <stan/math/rev/fun/polar.hpp>
diff --git a/stan/math/rev/fun/ode_store_sensitivities.hpp b/stan/math/rev/fun/ode_store_sensitivities.hpp
new file mode 100644
index 00000000000..47448d94bd2
--- /dev/null
+++ b/stan/math/rev/fun/ode_store_sensitivities.hpp
@@ -0,0 +1,56 @@
+#ifndef STAN_MATH_REV_FUN_ODE_STORE_SENSITIVITIES_HPP
+#define STAN_MATH_REV_FUN_ODE_STORE_SENSITIVITIES_HPP
+
+#include <stan/math/prim/fun/ode_store_sensitivities.hpp>
+#include <stan/math/rev/core.hpp>
+#include <ostream>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+template <typename T_initial, typename... Args>
+std::vector<var> ode_store_sensitivities(const std::vector<double>& coupled_state,
+					 const std::vector<T_initial>& y0,
+					 const Args&... args) {
+  const size_t N = y0.size();
+  const size_t y0_vars = count_vars(y0);
+  const size_t args_vars = count_vars(args...);
+  std::vector<var> yt;
+    
+  for (size_t j = 0; j < N; j++) {
+    const size_t total_vars = y0_vars + args_vars;
+
+    vari** varis = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
+    double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(total_vars);
+
+    vari** varis_ptr = varis;
+    double* partials_ptr = partials;
+
+
+    // iterate over parameters for each equation
+    varis_ptr = save_varis(varis_ptr, y0);
+    for (std::size_t k = 0; k < y0_vars; k++) {
+      //*varis_ptr = y0[k].vi_;
+      *partials_ptr = coupled_state[N + y0_vars * k + j];
+      partials_ptr++;
+    }
+
+    varis_ptr = save_varis(varis_ptr, args...);
+    for (std::size_t k = 0; k < args_vars; k++) {
+      // dy[j]_dtheta[k]
+      // theta[k].vi_
+      *partials_ptr = coupled_state[N + N * y0_vars + N * k + j];
+      partials_ptr++;
+    }
+
+    yt.emplace_back(new precomputed_gradients_vari(coupled_state[j], total_vars, varis, partials));
+  }
+
+  return yt;
+}
+
+} // namespace math
+} // namespace stan
+
+#endif
diff --git a/stan/math/rev/functor.hpp b/stan/math/rev/functor.hpp
index d1f31aef725..dc58245ab95 100644
--- a/stan/math/rev/functor.hpp
+++ b/stan/math/rev/functor.hpp
@@ -14,7 +14,9 @@
 #include <stan/math/rev/functor/integrate_dae.hpp>
 #include <stan/math/rev/functor/integrate_ode_adams.hpp>
 #include <stan/math/rev/functor/integrate_ode_bdf.hpp>
+#include <stan/math/rev/functor/ode_add_time_gradients.hpp>
 #include <stan/math/rev/functor/ode_bdf.hpp>
+#include <stan/math/rev/functor/ode_rk45.hpp>
 #include <stan/math/rev/functor/jacobian.hpp>
 #include <stan/math/rev/functor/kinsol_data.hpp>
 #include <stan/math/rev/functor/kinsol_solve.hpp>
diff --git a/stan/math/rev/functor/coupled_ode_rhs.hpp b/stan/math/rev/functor/coupled_ode_rhs.hpp
new file mode 100644
index 00000000000..f2d43ae6576
--- /dev/null
+++ b/stan/math/rev/functor/coupled_ode_rhs.hpp
@@ -0,0 +1,75 @@
+#ifndef STAN_MATH_REV_FUNCTOR_COUPLED_ODE_RHS_HPP
+#define STAN_MATH_REV_FUNCTOR_COUPLED_ODE_RHS_HPP
+
+#include <stan/math/rev/fun/value_of.hpp>
+#include <stan/math/rev/core.hpp>
+#include <stan/math/prim/err.hpp>
+#include <ostream>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+namespace internal {
+template <typename F, typename T_y, typename... Args>
+std::vector<double> coupled_ode_rhs(const F& f,
+				    double t,
+				    const std::vector<T_y>& y,
+				    std::ostream* msgs,
+				    const Args&... args) const {
+  // Run nested autodiff in this scope
+  nested_rev_autodiff nested;
+
+  int N = y.size();
+  const size_t y_vars = count_vars(y);
+  const size_t args_vars = count_vars(args...);
+  std::vector<double> dz_dt(N + N * y_vars + N * args_vars);
+  const std::vector<var> y_vars(y.begin(), y.end());
+  std::tuple<decltype(deep_copy_vars(args))...> local_args_tuple(deep_copy_vars(args)...);
+    
+  std::vector<var> dy_dt_vars = apply([&](auto&&... args) {
+      f_(t, y_vars, msgs_, args...);
+    }, local_args_tuple);
+
+  check_size_match("coupled_ode_system", "dy_dt", dy_dt_vars.size(), "states",
+		   N);
+
+  for (size_t i = 0; i < N; ++i) {
+    dz_dt[i] = dy_dt_vars[i].val();
+    dy_dt_vars[i].grad();
+
+    for (size_t j = 0; j < y0_vars_; ++j) {
+      // orders derivatives by equation (i.e. if there are 2 eqns
+      // (y1, y2) and 2 parameters (a, b), dy_dt will be ordered as:
+      // dy1_dt, dy2_dt, dy1_da, dy2_da, dy1_db, dy2_db
+      double temp_deriv = 0;
+      const size_t offset = N + N * j;
+      for (size_t k = 0; k < N; k++) {
+	temp_deriv += z[N + N * j + k] * y_vars[k].adj();
+      }
+	
+      dz_dt[N + N * j + i] = temp_deriv;
+    }
+      
+    Eigen::VectorXd args_adjoints = Eigen::VectorXd::Zero(args_vars);
+    apply([&](auto&&... args) {
+	accumulate_adjoints(args_adjoints.data(), args...);
+      }, local_args_tuple);
+
+    for (size_t j = 0; j < args_vars; j++) {
+      double temp_deriv = args_adjoints(j);
+      for (size_t k = 0; k < N; k++) {
+	temp_deriv += z[N + N * y0_vars + N * j + k] * y_vars[k].adj();
+      }
+	
+      dz_dt[N + N * y0_vars + N * j + i] = temp_deriv;
+    }
+      
+    nested.set_zero_all_adjoints();
+  }
+}
+
+}  // namespace internal
+}  // namespace math
+}  // namespace stan
+#endif
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index 515fdcaf322..c7fcfcf3b9b 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -62,10 +62,8 @@ namespace math {
  *          std::vector<double> x, std::vector<int>x_int, std::ostream*
  * msgs)</code>
  */
-template <typename T_initial, typename T_t0, typename T_ts, typename F, typename... Args>
-struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
-  using T_Return = return_type_t<T_initial, T_t0, T_ts, Args...>;
-
+template <typename F, typename T_initial, typename... Args>
+struct coupled_ode_system_impl<false, F, T_initial, Args...> {
   const F& f_;
   const std::vector<T_initial>& y0_;
   std::tuple<const Args&...> args_tuple_;
@@ -86,14 +84,15 @@ struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
    * @param[in] x_int integer data
    * @param[in, out] msgs stream for messages
    */
-  coupled_ode_system_impl(const F& f, const std::vector<T_initial>& y0,
+  coupled_ode_system_impl(const F& f,
+			  const std::vector<T_initial>& y0,
 			  std::ostream* msgs,
 			  const Args&... args)
       : f_(f),
         y0_(y0),
         args_tuple_(args...),
-        y0_vars_(internal::count_vars(y0_)),
-        args_vars_(internal::count_vars(args...)),
+        y0_vars_(count_vars(y0_)),
+        args_vars_(count_vars(args...)),
         N_(y0.size()),
         msgs_(msgs) {}
 
@@ -119,23 +118,20 @@ struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
     nested_rev_autodiff nested;
 
     const vector<var> y_vars(z.begin(), z.begin() + N_);
-    auto local_args_tuple = apply(
-				  [&](auto&&... args) {
-				    return std::tuple<decltype(internal::deep_copy(args))...>(
-											      internal::deep_copy(args)...);
-				  },
-				  args_tuple_);
+    auto local_args_tuple = apply([&](auto&&... args) {
+      return std::tuple<decltype(deep_copy_vars(args))...>(deep_copy_vars(args)...);
+      }, args_tuple_);
     
-    vector<var> dy_dt_vars = apply(
-				   [&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
-				   local_args_tuple);
+    vector<var> f_y_t_vars = apply(
+      [&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
+      local_args_tuple);
 
-    check_size_match("coupled_ode_system", "dz_dt", dy_dt_vars.size(), "states",
+    check_size_match("coupled_ode_system", "dy_dt", f_y_t_vars.size(), "states",
                      N_);
 
     for (size_t i = 0; i < N_; i++) {
-      dz_dt[i] = dy_dt_vars[i].val();
-      dy_dt_vars[i].grad();
+      dz_dt[i] = f_y_t_vars[i].val();
+      f_y_t_vars[i].grad();
       for (size_t j = 0; j < y0_vars_; j++) {
 	// orders derivatives by equation (i.e. if there are 2 eqns
 	// (y1, y2) and 2 parameters (a, b), dy_dt will be ordered as:
@@ -152,7 +148,7 @@ struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
       Eigen::VectorXd args_adjoints = Eigen::VectorXd::Zero(args_vars_);
       apply(
 	    [&](auto&&... args) {
-	      internal::accumulate_adjoints(args_adjoints.data(), args...);
+	      accumulate_adjoints(args_adjoints.data(), args...);
 	    },
 	    local_args_tuple);
       for (size_t j = 0; j < args_vars_; j++) {
@@ -168,75 +164,6 @@ struct coupled_ode_system_impl<false, T_initial, T_t0, T_ts, F, Args...> {
     }
   }
 
-  template<typename T_t>
-  std::vector<var> build_output(const std::vector<double>& dy0_dt0, const std::vector<double>& coupled_state, const T_t0& t0, const T_t& t) const {
-    std::vector<double> y_dbl(coupled_state.data(), coupled_state.data() + N_);
-
-    std::vector<var> yt;
-    yt.reserve(N_);
-    
-    std::vector<double> dy_dt;
-    if (is_var<T_t>::value) {
-      std::vector<double> y_dbl(coupled_state.begin(),
-                                coupled_state.begin() + N_);
-      /*vector<var> dy_dt_vars = apply([&](const Args&... args) {
-	  return f_(t, y_vars, args..., msgs_);
-	  }, local_args_tuple);*/
-      dy_dt = apply([&](auto&&... args) {
-	  return f_(value_of(t), y_dbl, msgs_, value_of(args)...);
-	}, args_tuple_);
-      check_size_match("coupled_ode_observer", "dy_dt", dy_dt.size(), "states", N_);
-    }
-    
-    for (size_t j = 0; j < N_; j++) {
-      // When true this is 1 and not ts_.size() because there's
-      //   only one time point involved with this output
-      const size_t total_vars = y0_vars_ + args_vars_ + ((is_var<T_t>::value) ? 1 : 0) + ((is_var<T_t0>::value) ? 1 : 0);
-
-      vari** varis = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
-      double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(total_vars);
-
-      vari** varis_ptr = varis;
-      double* partials_ptr = partials;
-
-      // iterate over parameters for each equation
-      varis_ptr = internal::save_varis(varis_ptr, y0_);
-      for (std::size_t k = 0; k < y0_vars_; k++) {
-	//*varis_ptr = y0[k].vi_;
-	*partials_ptr = coupled_state[N_ + y0_vars_ * k + j];
-	partials_ptr++;
-      }
-
-      varis_ptr = apply([&varis_ptr](auto&&... args) {
-	  return internal::save_varis(varis_ptr, args...);
-	}, args_tuple_);
-      for (std::size_t k = 0; k < args_vars_; k++) {
-	// dy[j]_dtheta[k]
-	// theta[k].vi_
-	*partials_ptr = coupled_state[N_ + N_ * y0_vars_ + N_ * k + j];
-	partials_ptr++;
-      }
-
-      if ((stan::is_var<T_t>::value) ? 1 : 0) {
-	varis_ptr = internal::save_varis(varis_ptr, t);
-	*partials_ptr = dy_dt[j];
-	partials_ptr++;
-	// dy[j]_dcurrent_t
-      }
-
-      if ((stan::is_var<T_t0>::value) ? 1 : 0) {
-	varis_ptr = internal::save_varis(varis_ptr, t0);
-	*partials_ptr = -dy0_dt0[j];
-	partials_ptr++;
-	// dy[j]_dcurrent_t
-      }
-
-      yt.emplace_back(new precomputed_gradients_vari(coupled_state[j], total_vars, varis, partials));
-    }
-
-    return yt;
-  }
-
   /**
    * Returns the size of the coupled system.
    *
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 57bcf77c8ca..9af02ab5cfd 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/functor/cvodes_utils.hpp>
 #include <stan/math/rev/functor/coupled_ode_system.hpp>
+#include <stan/math/rev/fun/ode_store_sensitivities.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/value_of.hpp>
 #include <cvodes/cvodes.h>
@@ -22,15 +23,16 @@ namespace math {
  * @tparam Lmm ID of ODE solver (1: ADAMS, 2: BDF)
  */
 template <int Lmm, typename F, typename T_initial,
-	  typename T_t0, typename T_ts, typename... T_Args>
+	  typename... T_Args>
 class cvodes_integrator {
-  using T_Return = return_type_t<T_initial, T_t0, T_ts, T_Args...>;
+  using T_Return = return_type_t<T_initial, T_Args...>;
 
   const F& f_;
   const std::vector<T_initial>& y0_;
-  const T_t0& t0_;
-  const std::vector<T_ts>& ts_;
+  double t0_;
+  const std::vector<double>& ts_;
   std::tuple<const T_Args&...> args_tuple_;
+  std::tuple<decltype(value_of(T_Args()))...> value_of_args_tuple_;
   const size_t N_;
   std::ostream* msgs_;
   double relative_tolerance_;
@@ -40,7 +42,7 @@ class cvodes_integrator {
   const size_t y0_vars_;
   const size_t args_vars_;
 
-  const coupled_ode_system<T_initial, T_t0, T_ts, F, T_Args...> coupled_ode_;
+  coupled_ode_system<F, T_initial, T_Args...> coupled_ode_;
 
   std::vector<double> coupled_state_;
   N_Vector nv_state_;
@@ -48,69 +50,6 @@ class cvodes_integrator {
   SUNMatrix A_;
   SUNLinearSolver LS_;
 
-public:
-  cvodes_integrator(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
-		    const std::vector<T_ts>& ts, double relative_tolerance,
-		    double absolute_tolerance,
-		    long int max_num_steps,
-		    std::ostream* msgs, const T_Args&... args)
-    : f_(f),
-      y0_(y0),
-      t0_(t0),
-      ts_(ts),
-      args_tuple_(args...),
-      N_(y0.size()),
-      msgs_(msgs),
-      relative_tolerance_(relative_tolerance),
-      absolute_tolerance_(absolute_tolerance),
-      max_num_steps_(max_num_steps),
-      y0_vars_(internal::count_vars(y0_)),
-      args_vars_(internal::count_vars(args...)),
-      coupled_ode_(f, y0, msgs, args...),
-      coupled_state_(coupled_ode_.initial_state()) {
-    using initial_var = stan::is_var<T_initial>;
-
-    const char* fun = "cvodes_integrator::integrate";
-
-    check_finite(fun, "initial state", y0_);
-    check_finite(fun, "initial time", t0_);
-    check_finite(fun, "times", ts_);
-
-    // Code from: https://stackoverflow.com/a/17340003 . Should probably do something better
-    apply([&](auto&&... args) {
-	std::vector<int> unused_temp{ 0, (check_finite(fun, "ode parameters and data", args), 0)... };
-      }, args_tuple_);
-
-    check_nonzero_size(fun, "times", ts_);
-    check_nonzero_size(fun, "initial state", y0_);
-    check_ordered(fun, "times", ts_);
-    check_less(fun, "initial time", t0_, ts_[0]);
-    check_positive_finite(fun, "relative_tolerance", relative_tolerance_);
-    check_positive_finite(fun, "absolute_tolerance", absolute_tolerance_);
-    check_positive(fun, "max_num_steps", max_num_steps_);
-
-    nv_state_ = N_VMake_Serial(N_, &coupled_state_[0]);
-    nv_state_sens_ = nullptr;
-    A_ = SUNDenseMatrix(N_, N_);
-    LS_ = SUNDenseLinearSolver(nv_state_, A_);
-
-    if (y0_vars_ + args_vars_ > 0) {
-      nv_state_sens_ = N_VCloneVectorArrayEmpty_Serial(y0_vars_ + args_vars_, nv_state_);
-      for (std::size_t i = 0; i < y0_vars_ + args_vars_; i++) {
-        NV_DATA_S(nv_state_sens_[i]) = &coupled_state_[N_] + i * N_;
-      }
-    }
-  }
-
-  ~cvodes_integrator() {
-    SUNLinSolFree(LS_);
-    SUNMatDestroy(A_);
-    N_VDestroy_Serial(nv_state_);
-    if (y0_vars_ + args_vars_ > 0) {
-      N_VDestroyVectorArray_Serial(nv_state_sens_, y0_vars_ + args_vars_);
-    }
-  }
-
   /**
    * Implements the function of type CVRhsFn which is the user-defined
    * ODE RHS passed to CVODES.
@@ -146,6 +85,7 @@ class cvodes_integrator {
     integrator->jacobian_states(t, NV_DATA_S(y), J);
     return 0;
   }
+
   /**
    * Calculates the ODE RHS, dy_dt, using the user-supplied functor at
    * the given time t and state y.
@@ -153,9 +93,9 @@ class cvodes_integrator {
   inline void rhs(double t, const double y[], double dy_dt[]) const {
     const std::vector<double> y_vec(y, y + N_);
     std::vector<double> dy_dt_vec = apply([&](auto&&... args) {
-	return f_(t, y_vec, msgs_, value_of(args)...);
-      }, args_tuple_);
-    check_size_match("cvodes_ode_data", "dz_dt", dy_dt_vec.size(), "states",
+	return f_(t, y_vec, msgs_, args...);
+      }, value_of_args_tuple_);
+    check_size_match("cvodes_integrator::rhs", "dy_dt", dy_dt_vec.size(), "states",
                      N_);
     std::move(dy_dt_vec.begin(), dy_dt_vec.end(), dy_dt);
   }
@@ -163,24 +103,24 @@ class cvodes_integrator {
   /**
    * Calculates the jacobian of the ODE RHS wrt to its states y at the
    * given time-point t and state y.
-   * Note that the jacobian of the ODE system is the coupled ode system for
-   * varying states evaluated at the state y whenever we choose state
-   * y to be the initial of the coupled ode system.
    */
   inline void jacobian_states(double t, const double y[], SUNMatrix J) const {
-    start_nested();
-    const std::vector<var> y_vec_var(y, y + N_);
-    // TODO: This should only be done once on construction
-    auto double_args_tuple = apply([&](auto&&... args) {
-	return std::make_tuple(value_of(args)...);
-      }, args_tuple_);
-    auto ode_jacobian = apply([&](auto&&... args) {
-	return coupled_ode_system<var, double, double, F, decltype(args)...>(f_, y_vec_var, msgs_, args...);
-      }, double_args_tuple);
-    std::vector<double>&& jacobian_y = std::vector<double>(ode_jacobian.size());
-    ode_jacobian(ode_jacobian.initial_state(), jacobian_y, t);
-    std::move(jacobian_y.begin() + N_, jacobian_y.end(), SM_DATA_D(J));
-    recover_memory_nested();
+    Eigen::VectorXd fy;
+    Eigen::MatrixXd Jfy;
+
+    auto f_wrapped = [&](const Eigen::Matrix<var, Eigen::Dynamic, 1>& y) {
+      return to_vector(apply([&](auto&&... args) {
+	    return f_(t, to_array_1d(y), msgs_, args...);
+	  }, value_of_args_tuple_));
+    };
+    
+    jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(y, N_), fy, Jfy);
+
+    for(size_t j = 0; j < Jfy.cols(); ++j) {
+      for(size_t i = 0; i < Jfy.rows(); ++i) {
+	SM_ELEMENT_D(J, i, j) = Jfy(i, j);
+      }
+    }
   }
 
   /**
@@ -205,6 +145,73 @@ class cvodes_integrator {
     }
   }
 
+public:
+  cvodes_integrator(const F& f,
+		    const std::vector<T_initial>& y0,
+		    double t0,
+		    const std::vector<double>& ts,
+		    double relative_tolerance,
+		    double absolute_tolerance,
+		    long int max_num_steps,
+		    std::ostream* msgs, const T_Args&... args)
+    : f_(f),
+      y0_(y0),
+      t0_(t0),
+      ts_(ts),
+      args_tuple_(args...),
+      value_of_args_tuple_(value_of(args)...),
+      N_(y0.size()),
+      msgs_(msgs),
+      relative_tolerance_(relative_tolerance),
+      absolute_tolerance_(absolute_tolerance),
+      max_num_steps_(max_num_steps),
+      y0_vars_(count_vars(y0_)),
+      args_vars_(count_vars(args...)),
+      coupled_ode_(f, y0, msgs, args...),
+      coupled_state_(coupled_ode_.initial_state()) {
+    using initial_var = stan::is_var<T_initial>;
+
+    const char* fun = "cvodes_integrator::integrate";
+
+    check_finite(fun, "initial state", y0_);
+    check_finite(fun, "initial time", t0_);
+    check_finite(fun, "times", ts_);
+
+    // Code from: https://stackoverflow.com/a/17340003 . Should probably do something better
+    apply([&](auto&&... args) {
+	std::vector<int> unused_temp{ 0, (check_finite(fun, "ode parameters and data", args), 0)... };
+      }, args_tuple_);
+
+    check_nonzero_size(fun, "times", ts_);
+    check_nonzero_size(fun, "initial state", y0_);
+    check_ordered(fun, "times", ts_);
+    check_less(fun, "initial time", t0_, ts_[0]);
+    check_positive_finite(fun, "relative_tolerance", relative_tolerance_);
+    check_positive_finite(fun, "absolute_tolerance", absolute_tolerance_);
+    check_positive(fun, "max_num_steps", max_num_steps_);
+
+    nv_state_ = N_VMake_Serial(N_, &coupled_state_[0]);
+    nv_state_sens_ = nullptr;
+    A_ = SUNDenseMatrix(N_, N_);
+    LS_ = SUNDenseLinearSolver(nv_state_, A_);
+
+    if (y0_vars_ + args_vars_ > 0) {
+      nv_state_sens_ = N_VCloneVectorArrayEmpty_Serial(y0_vars_ + args_vars_, nv_state_);
+      for (std::size_t i = 0; i < y0_vars_ + args_vars_; i++) {
+        NV_DATA_S(nv_state_sens_[i]) = &coupled_state_[N_] + i * N_;
+      }
+    }
+  }
+
+  ~cvodes_integrator() {
+    SUNLinSolFree(LS_);
+    SUNMatDestroy(A_);
+    N_VDestroy_Serial(nv_state_);
+    if (y0_vars_ + args_vars_ > 0) {
+      N_VDestroyVectorArray_Serial(nv_state_sens_, y0_vars_ + args_vars_);
+    }
+  }
+
   /**
    * Return the solutions for the specified system of ordinary
    * differential equations given the specified initial state,
@@ -251,15 +258,6 @@ class cvodes_integrator {
     const double t0_dbl = value_of(t0_);
     const std::vector<double> ts_dbl = value_of(ts_);
 
-    std::vector<double> dy0_dt0;
-    if (is_var<T_t0>::value) {
-      std::vector<double> y0_dbl = value_of(y0_);
-      dy0_dt0 = apply([&](auto&&... args) {
-	  return f_(value_of(t0_), y0_dbl, msgs_, value_of(args)...);
-	}, args_tuple_);
-      check_size_match("coupled_ode_observer", "dy_dt", dy0_dt0.size(), "states", N_);
-    }
-
     void* cvodes_mem = CVodeCreate(Lmm);
     if (cvodes_mem == nullptr) {
       throw std::runtime_error("CVodeCreate failed to allocate memory");
@@ -312,8 +310,9 @@ class cvodes_integrator {
               "CVodeGetSens");
         }
 
-        //observer(cvodes_data.coupled_state_, t_final);
-	y.emplace_back(coupled_ode_.build_output(dy0_dt0, coupled_state_, t0_, ts_[n]));
+	y.emplace_back(apply([&](auto&&... args) {
+	      return ode_store_sensitivities(coupled_state_, y0_, args...);
+	    }, args_tuple_));
 
 	t_init = t_final;
       }
diff --git a/stan/math/rev/functor/integrate_ode_bdf.hpp b/stan/math/rev/functor/integrate_ode_bdf.hpp
index a40703de54a..29c3b081c5f 100644
--- a/stan/math/rev/functor/integrate_ode_bdf.hpp
+++ b/stan/math/rev/functor/integrate_ode_bdf.hpp
@@ -1,8 +1,7 @@
 #ifndef STAN_MATH_REV_FUNCTOR_INTEGRATE_ODE_BDF_HPP
 #define STAN_MATH_REV_FUNCTOR_INTEGRATE_ODE_BDF_HPP
 
-#include <stan/math/rev/meta.hpp>
-#include <stan/math/rev/functor/cvodes_integrator.hpp>
+#include <stan/math/rev/functor/ode_bdf.hpp>
 #include <ostream>
 #include <vector>
 
@@ -20,13 +19,11 @@ integrate_ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
                   double relative_tolerance = 1e-10,
                   double absolute_tolerance = 1e-10,
                   long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
-  stan::math::cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts,
-				std::vector<T_param>,
-				std::vector<double>,
-				std::vector<int>> integrator(f, y0, t0, ts, theta, x, x_int, msgs,
-							     relative_tolerance, absolute_tolerance,
-							     max_num_steps);
-  return integrator.integrate();
+  return ode_bdf_tol(f, y0, t0, ts,
+		     relative_tolerance, absolute_tolerance,
+		     max_num_steps,
+		     msgs,
+		     theta, x, x_int);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/ode_add_time_gradients.hpp b/stan/math/rev/functor/ode_add_time_gradients.hpp
new file mode 100644
index 00000000000..f770153db2e
--- /dev/null
+++ b/stan/math/rev/functor/ode_add_time_gradients.hpp
@@ -0,0 +1,75 @@
+#ifndef STAN_MATH_REV_FUNCTOR_ODE_ADD_TIME_GRADIENTS_HPP
+#define STAN_MATH_REV_FUNCTOR_ODE_ADD_TIME_GRADIENTS_HPP
+
+#include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/core.hpp>
+#include <ostream>
+#include <vector>
+
+namespace stan {
+namespace math {
+namespace internal {
+double ode_time_gradient_var(double t, double grad) {
+  invalid_argument("ode_time_gradient_var", "t", t, "t must be of type var, not double");
+  return 0.0;
+}
+
+var ode_time_gradient_var(var t, double grad) {
+  return var(new precomp_v_vari(0.0, t.vi_, grad));
+}
+}; // namespace internal
+
+template <typename F, typename T_initial,
+	  typename T_out, typename... T_Args>
+auto ode_add_time_gradients(const F& f,
+			    const std::vector<T_initial>& y0,
+			    double t0,
+			    const std::vector<double>& ts,
+			    const std::vector<std::vector<T_out>>& y,
+			    std::ostream* msgs,
+			    const T_Args&... args) {
+  return y;
+}
+
+template <typename F, typename T_initial, typename T_t0, typename T_ts,
+	  typename T_out, typename... T_Args>
+std::vector<std::vector<var>> ode_add_time_gradients(const F& f,
+						     const std::vector<T_initial>& y0,
+						     const T_t0& t0,
+						     const std::vector<T_ts>& ts,
+						     const std::vector<std::vector<T_out>>& y,
+						     std::ostream* msgs,
+						     const T_Args&... args) {
+  std::vector<double> f_y0_t0 = {};
+  if(is_var<T_t0>::value) {
+    f_y0_t0 = f(value_of(t0), value_of(y0), msgs, value_of(args)...);
+
+    check_size_match("coupled_ode_observer", "dy_dt", f_y0_t0.size(), "states", y0.size());
+  }
+
+  std::vector<std::vector<var>> y_with_gradients(y.size());
+
+  for(size_t i = 0; i < y.size(); ++i) {
+    std::vector<double> f_y_t = {};
+    if(is_var<T_ts>::value)
+      f_y_t = f(value_of(ts[i]), value_of(y[i]), msgs, value_of(args)...);
+
+    for(size_t j = 0; j < y[i].size(); ++j) {
+      var tmp = y[i][j];
+
+      if(is_var<T_t0>::value)
+	tmp += internal::ode_time_gradient_var(t0, -f_y0_t0[j]);
+
+      if(is_var<T_ts>::value)
+	tmp += internal::ode_time_gradient_var(ts[i], f_y_t[j]);
+
+      y_with_gradients[i].push_back(tmp);
+    }
+  }
+
+  return y_with_gradients;
+}
+
+}  // namespace math
+}  // namespace stan
+#endif
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index d50322068ce..4eab6355087 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -2,6 +2,7 @@
 #define STAN_MATH_REV_FUNCTOR_ODE_BDF_HPP
 
 #include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/functor/ode_add_time_gradients.hpp>
 #include <stan/math/rev/functor/cvodes_integrator.hpp>
 #include <ostream>
 #include <vector>
@@ -13,18 +14,42 @@ template <typename F, typename T_initial, typename T_t0, typename T_ts, typename
 std::vector<std::vector<typename stan::return_type<T_initial, T_t0, T_ts, T_Args...>::type>>
 ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
 	const std::vector<T_ts>& ts,
-	double relative_tolerance,
-	double absolute_tolerance,
-	long int max_num_steps,
 	std::ostream* msgs,
-	const T_Args&... args) {  // NOLINT(runtime/int)
-  stan::math::cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...>
-    integrator(f, y0, t0, ts,
+	const T_Args&... args) {
+  double relative_tolerance = 1e-6;
+  double absolute_tolerance = 1e-6;
+  long int max_num_steps = 1e6;
+
+  return ode_bdf_tol(f, y0, t0, ts,
+		     relative_tolerance, absolute_tolerance,
+		     max_num_steps,
+		     msgs,
+		     args...);
+}
+
+template <typename F, typename T_initial, typename T_t0, typename T_ts, typename... T_Args>
+std::vector<std::vector<typename stan::return_type<T_initial, T_t0, T_ts, T_Args...>::type>>
+ode_bdf_tol(const F& f, const std::vector<T_initial>& y0,
+	    const T_t0& t0,
+	    const std::vector<T_ts>& ts,
+	    double relative_tolerance,
+	    double absolute_tolerance,
+	    long int max_num_steps,
+	    std::ostream* msgs,
+	    const T_Args&... args) {
+  std::vector<double> value_of_ts = value_of(ts);
+  
+  stan::math::cvodes_integrator<CV_BDF, F, T_initial, T_Args...>
+    integrator(f, y0,
+	       value_of(t0), value_of_ts,
 	       relative_tolerance, absolute_tolerance,
 	       max_num_steps,
 	       msgs,
 	       args...);
-  return integrator.integrate();
+
+  auto y = integrator.integrate();
+  
+  return ode_add_time_gradients(f, y0, t0, ts, y, msgs, args...);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/ode_rk45.hpp b/stan/math/rev/functor/ode_rk45.hpp
new file mode 100644
index 00000000000..7809f406f66
--- /dev/null
+++ b/stan/math/rev/functor/ode_rk45.hpp
@@ -0,0 +1,50 @@
+#ifndef STAN_MATH_REV_FUNCTOR_ODE_RK45_HPP
+#define STAN_MATH_REV_FUNCTOR_ODE_RK45_HPP
+
+#include <stan/math/rev/meta.hpp>
+#include <stan/math/prim/functor/ode_rk45.hpp>
+#include <ostream>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+template <typename F, typename T_initial, typename T_t0, typename T_ts, typename... T_Args>
+std::vector<std::vector<var>>
+ode_rk45(const F& f, const std::vector<T_initial>& y0,
+	 const T_t0& t0,
+	 const std::vector<T_ts>& ts,
+	 std::ostream* msgs,
+	 const T_Args&... args) {
+  double relative_tolerance = 1e-6;
+  double absolute_tolerance = 1e-6;
+  long int max_num_steps = 1e6;
+
+  return ode_rk45_tol(f, y0, t0, ts,
+		      relative_tolerance, absolute_tolerance,
+		      max_num_steps,
+		      msgs,
+		      args...);
+}
+  
+template <typename F, typename T_initial, typename T_t0, typename T_ts, typename... T_Args>
+std::vector<std::vector<var>>
+ode_rk45_tol(const F& f, const std::vector<T_initial>& y0,
+	     const T_t0& t0,
+	     const std::vector<T_ts>& ts,
+	     double relative_tolerance,
+	     double absolute_tolerance,
+	     long int max_num_steps,
+	     std::ostream* msgs,
+	     const T_Args&... args) {
+
+  auto y = ode_rk45_tol(f, y0, value_of(t0), value_of(ts),
+			relative_tolerance, absolute_tolerance,
+			max_num_steps, msgs, args...);
+
+  return ode_add_time_gradients(f, y0, t0, ts, y, msgs, args...);
+}
+
+}  // namespace math
+}  // namespace stan
+#endif
diff --git a/test/unit/math/prim/functor/forced_harmonic_oscillator.hpp b/test/unit/math/prim/functor/forced_harmonic_oscillator.hpp
index 5161e021683..f2c250d2c35 100644
--- a/test/unit/math/prim/functor/forced_harmonic_oscillator.hpp
+++ b/test/unit/math/prim/functor/forced_harmonic_oscillator.hpp
@@ -14,8 +14,9 @@ struct forced_harm_osc_ode_fun {
   // double data
   // integer data
   operator()(const T0& t_in, const std::vector<T1>& y_in,
+	     std::ostream* msgs,
              const std::vector<T2>& theta, const std::vector<double>& x,
-             const std::vector<int>& x_int, std::ostream* msgs) const {
+             const std::vector<int>& x_int) const {
     if (y_in.size() != 2)
       throw std::domain_error(
           "this function was called with inconsistent state");
diff --git a/test/unit/math/prim/functor/harmonic_oscillator.hpp b/test/unit/math/prim/functor/harmonic_oscillator.hpp
index fc5a6bae3f7..86c221498d1 100644
--- a/test/unit/math/prim/functor/harmonic_oscillator.hpp
+++ b/test/unit/math/prim/functor/harmonic_oscillator.hpp
@@ -14,8 +14,9 @@ struct harm_osc_ode_fun {
   // double data
   // integer data
   operator()(const T0& t_in, const std::vector<T1>& y_in,
+	     std::ostream* msgs,
              const std::vector<T2>& theta, const std::vector<double>& x,
-             const std::vector<int>& x_int, std::ostream* msgs) const {
+             const std::vector<int>& x_int) const {
     if (y_in.size() != 2)
       throw std::domain_error(
           "this function was called with inconsistent state");
@@ -37,8 +38,9 @@ struct harm_osc_ode_data_fun {
   // double data
   // integer data
   operator()(const T0& t_in, const std::vector<T1>& y_in,
+	     std::ostream* msgs,
              const std::vector<T2>& theta, const std::vector<double>& x,
-             const std::vector<int>& x_int, std::ostream* msgs) const {
+             const std::vector<int>& x_int) const {
     if (y_in.size() != 2)
       throw std::domain_error(
           "this function was called with inconsistent state");
@@ -61,8 +63,9 @@ struct harm_osc_ode_wrong_size_1_fun {
   // double data
   // integer data
   operator()(const T0& t_in, const std::vector<T1>& y_in,
+	     std::ostream* msgs,
              const std::vector<T2>& theta, const std::vector<double>& x,
-             const std::vector<int>& x_int, std::ostream* msgs) const {
+             const std::vector<int>& x_int) const {
     if (y_in.size() != 2)
       throw std::domain_error(
           "this function was called with inconsistent state");
@@ -85,8 +88,9 @@ struct harm_osc_ode_wrong_size_2_fun {
   // double data
   // integer data
   operator()(const T0& t_in, const std::vector<T1>& y_in,
+	     std::ostream* msgs,
              const std::vector<T2>& theta, const std::vector<double>& x,
-             const std::vector<int>& x_int, std::ostream* msgs) const {
+             const std::vector<int>& x_int) const {
     if (y_in.size() != 2)
       throw std::domain_error(
           "this function was called with inconsistent state");
diff --git a/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp b/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
index 2d91e362f4a..f229724ba60 100644
--- a/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
+++ b/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
@@ -15,7 +15,7 @@ template <typename F, typename... Args>
 void sho_death_test(F harm_osc, std::vector<double>& y0, double t0,
                     std::vector<double>& ts, Args&... args) {
   EXPECT_DEATH(
-      stan::math::integrate_ode_rk45<Args...>(harm_osc, y0, t0, ts, args...),
+      stan::math::integrate_ode_rk45(harm_osc, y0, t0, ts, args...),
       "");
 }
 
@@ -23,7 +23,7 @@ template <typename F, typename... Args>
 void sho_value_test(F harm_osc, std::vector<double>& y0, double t0,
                     std::vector<double>& ts, Args&... args) {
   std::vector<std::vector<double>> ode_res_vd
-      = stan::math::integrate_ode_rk45<Args...>(harm_osc, y0, t0, ts, args...);
+      = stan::math::integrate_ode_rk45(harm_osc, y0, t0, ts, args...);
   EXPECT_NEAR(0.995029, ode_res_vd[0][0], 1e-5);
   EXPECT_NEAR(-0.0990884, ode_res_vd[0][1], 1e-5);
 
@@ -101,68 +101,46 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions) {
   std::vector<double> x(3, 1);
   std::vector<int> x_int(2, 0);
 
-  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                      std::vector<int>>(harm_osc, y0, t0, ts,
-                                                        theta, x, x_int)));
+  ASSERT_NO_THROW((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int)));
 
   std::vector<double> y0_bad;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0_bad, t0,
-                                                         ts, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
                    std::invalid_argument, "initial state has size 0");
 
   double t0_bad = 2.0;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0, t0_bad,
-                                                         ts, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
                    std::domain_error,
                    "initial time is 2, but must be less than 0.1");
 
   std::vector<double> ts_bad;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(
-                       harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
                    std::invalid_argument, "times has size 0");
 
   ts_bad.push_back(3);
   ts_bad.push_back(1);
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(
-                       harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
                    std::domain_error, "times is not a valid ordered vector");
 
   std::vector<double> theta_bad;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0, t0, ts,
-                                                         theta_bad, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
                    std::out_of_range, "vector");
 
   std::vector<double> x_bad;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0, t0, ts,
-                                                         theta, x_bad, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
                    std::out_of_range, "vector");
 
   std::vector<int> x_int_bad;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0, t0, ts,
-                                                         theta, x, x_int_bad)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int_bad)),
                    std::out_of_range, "vector");
 
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(
-                       harm_osc, y0, t0, ts, theta, x, x_int, 0, -1, 1e-6, 10)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int, 0, -1, 1e-6, 10)),
                    std::invalid_argument, "relative_tolerance");
 
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(
-                       harm_osc, y0, t0, ts, theta, x, x_int, 0, 1e-6, -1, 10)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int, 0, 1e-6, -1, 10)),
                    std::invalid_argument, "absolute_tolerance");
 
   EXPECT_THROW_MSG(
-      (integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                          std::vector<int>>(harm_osc, y0, t0, ts, theta, x,
-                                            x_int, 0, 1e-6, 1e-6, -1)),
+      (integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int, 0, 1e-6, 1e-6, -1)),
       std::invalid_argument, "max_num_steps");
 }
 
@@ -186,9 +164,7 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions_nan) {
   std::vector<double> x(3, 1);
   std::vector<int> x_int(2, 0);
 
-  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                      std::vector<int>>(harm_osc, y0, t0, ts,
-                                                        theta, x, x_int)));
+  ASSERT_NO_THROW((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int)));
 
   double nan = std::numeric_limits<double>::quiet_NaN();
   std::stringstream expected_is_nan;
@@ -196,57 +172,37 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions_nan) {
 
   std::vector<double> y0_bad = y0;
   y0_bad[0] = nan;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0_bad, t0,
-                                                         ts, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
                    std::domain_error, "initial state");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0_bad, t0,
-                                                         ts, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
                    std::domain_error, expected_is_nan.str());
 
   double t0_bad = nan;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0, t0_bad,
-                                                         ts, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
                    std::domain_error, "initial time");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0, t0_bad,
-                                                         ts, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
                    std::domain_error, expected_is_nan.str());
 
   std::vector<double> ts_bad = ts;
   ts_bad[0] = nan;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(
-                       harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
                    std::domain_error, "times");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(
-                       harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
                    std::domain_error, expected_is_nan.str());
 
   std::vector<double> theta_bad = theta;
   theta_bad[0] = nan;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0, t0, ts,
-                                                         theta_bad, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
                    std::domain_error, "parameters and data");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0, t0, ts,
-                                                         theta_bad, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
                    std::domain_error, expected_is_nan.str());
 
   if (x.size() > 0) {
     std::vector<double> x_bad = x;
     x_bad[0] = nan;
-    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>,
-                                         std::vector<double>, std::vector<int>>(
-                         harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+    EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
                      std::domain_error, "parameters and data");
-    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>,
-                                         std::vector<double>, std::vector<int>>(
-                         harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+    EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
                      std::domain_error, expected_is_nan.str());
   }
 }
@@ -275,110 +231,68 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions_inf) {
   std::vector<double> x(3, 1);
   std::vector<int> x_int(2, 0);
 
-  ASSERT_NO_THROW((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                      std::vector<int>>(harm_osc, y0, t0, ts,
-                                                        theta, x, x_int)));
+  ASSERT_NO_THROW((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int)));
 
   double inf = std::numeric_limits<double>::infinity();
   std::vector<double> y0_bad = y0;
   y0_bad[0] = inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0_bad, t0,
-                                                         ts, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
                    std::domain_error, "initial state");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0_bad, t0,
-                                                         ts, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
                    std::domain_error, expected_is_inf.str());
 
   y0_bad[0] = -inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0_bad, t0,
-                                                         ts, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
                    std::domain_error, "initial state");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0_bad, t0,
-                                                         ts, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
                    std::domain_error, expected_is_neg_inf.str());
 
   double t0_bad = inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0, t0_bad,
-                                                         ts, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
                    std::domain_error, "initial time");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0, t0_bad,
-                                                         ts, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
                    std::domain_error, expected_is_inf.str());
   t0_bad = -inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0, t0_bad,
-                                                         ts, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
                    std::domain_error, "initial time");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0, t0_bad,
-                                                         ts, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
                    std::domain_error, expected_is_neg_inf.str());
 
   std::vector<double> ts_bad = ts;
   ts_bad.push_back(inf);
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(
-                       harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
                    std::domain_error, "times");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(
-                       harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
                    std::domain_error, expected_is_inf.str());
   ts_bad[0] = -inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(
-                       harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
                    std::domain_error, "times");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(
-                       harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
                    std::domain_error, expected_is_neg_inf.str());
 
   std::vector<double> theta_bad = theta;
   theta_bad[0] = inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0, t0, ts,
-                                                         theta_bad, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
                    std::domain_error, "parameters and data");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0, t0, ts,
-                                                         theta_bad, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
                    std::domain_error, expected_is_inf.str());
   theta_bad[0] = -inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0, t0, ts,
-                                                         theta_bad, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
                    std::domain_error, "parameters and data");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(harm_osc, y0, t0, ts,
-                                                         theta_bad, x, x_int)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
                    std::domain_error, expected_is_neg_inf.str());
 
   if (x.size() > 0) {
     std::vector<double> x_bad = x;
     x_bad[0] = inf;
-    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>,
-                                         std::vector<double>, std::vector<int>>(
-                         harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+    EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
                      std::domain_error, "parameters and data");
-    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>,
-                                         std::vector<double>, std::vector<int>>(
-                         harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+    EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
                      std::domain_error, expected_is_inf.str());
     x_bad[0] = -inf;
-    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>,
-                                         std::vector<double>, std::vector<int>>(
-                         harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+    EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
                      std::domain_error, "parameters and data");
-    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<double>,
-                                         std::vector<double>, std::vector<int>>(
-                         harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+    EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
                      std::domain_error, expected_is_neg_inf.str());
   }
 }
diff --git a/test/unit/math/prim/functor/lorenz.hpp b/test/unit/math/prim/functor/lorenz.hpp
index b523a890529..e905e78837c 100644
--- a/test/unit/math/prim/functor/lorenz.hpp
+++ b/test/unit/math/prim/functor/lorenz.hpp
@@ -30,8 +30,9 @@ struct lorenz_ode_fun {
   // double data
   // integer data
   operator()(const T0& t_in, const std::vector<T1>& y_in,
+	     std::ostream* msgs,
              const std::vector<T2>& theta, const std::vector<double>& x,
-             const std::vector<int>& x_int, std::ostream* msgs) const {
+             const std::vector<int>& x_int) const {
     return lorenz_ode(t_in, y_in, theta, x, x_int);
   }
 };
diff --git a/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp
index ee06bf44690..89bcca946e8 100644
--- a/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp
@@ -355,7 +355,7 @@ TEST(StanMathOde_integrate_ode_bdf, error_conditions_bad_ode) {
   std::vector<int> x_int(2, 0);
 
   std::string error_msg
-      = "cvodes_ode_data: dz_dt (3) and states (2) must match in size";
+      = "cvodes_integrator::rhs: dy_dt (3) and states (2) must match in size";
 
   EXPECT_THROW_MSG(integrate_ode_bdf(harm_osc, y0, t0, ts, theta, x, x_int, 0,
                                      1e-8, 1e-10, 1e6),
diff --git a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
index 987f49a61ee..897acd13159 100644
--- a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
@@ -129,7 +129,7 @@ TEST(StanAgradRevOde_integrate_ode_bdf, harmonic_oscillator_error) {
 
   // aligned error handling with non-stiff case
   std::string error_msg
-      = "cvodes_ode_data: dz_dt (3) and states (2) must match in size";
+      = "cvodes_integrator::rhs: dy_dt (3) and states (2) must match in size";
 
   sho_error_test<double, var>(harm_osc, y0, t0, ts, theta, x, x_int, error_msg);
   sho_error_test<var, double>(harm_osc, y0, t0, ts, theta, x, x_int, error_msg);
@@ -241,7 +241,7 @@ TEST(StanAgradRevOde_integrate_ode_bdf, time_steps_as_param_AD) {
           } else {
             std::vector<double> y0(res_d.begin(), res_d.begin() + ns);
             EXPECT_FLOAT_EQ(g[k],
-                            ode(ts[i].val(), y0, theta, x, x_int, msgs)[j]);
+                            ode(ts[i].val(), y0, msgs, theta, x, x_int)[j]);
           }
         }
         stan::math::set_zero_all_adjoints();
@@ -268,7 +268,7 @@ TEST(StanAgradRevOde_integrate_ode_bdf, t0_as_param_AD) {
   const int ns = 2;    // nb. of states
   std::ostream* msgs = NULL;
 
-  forced_harm_osc_ode_fun ode;
+  harm_osc_ode_fun ode;
 
   std::vector<double> theta{0.15, 0.25};
   std::vector<double> y0{1.0, 0.0};
@@ -287,10 +287,11 @@ TEST(StanAgradRevOde_integrate_ode_bdf, t0_as_param_AD) {
     for (auto i = 0; i < nt; ++i) {
       std::vector<double> res_d = value_of(res[i]);
       for (auto j = 0; j < ns; ++j) {
-        res[i][j].grad();
-        for (auto k = 0; k < nt; ++k) {
-          EXPECT_FLOAT_EQ(t0v.adj(), 0.0);
-        }
+        res[i][0].grad();
+	EXPECT_FLOAT_EQ(t0v.adj(), 0.0);
+        stan::math::set_zero_all_adjoints();
+        res[i][1].grad();
+	EXPECT_FLOAT_EQ(t0v.adj(), 1.0);
         stan::math::set_zero_all_adjoints();
       }
     }
diff --git a/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
index b5eb9c4e0be..b8f9bae8fdf 100644
--- a/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
@@ -17,8 +17,7 @@ void sho_value_test(F harm_osc, std::vector<double>& y0, double t0,
   using stan::math::var;
 
   std::vector<std::vector<var>> ode_res_vd
-      = stan::math::integrate_ode_rk45<std::vector<T_theta>,
-                                       std::vector<double>, std::vector<int>>(
+      = stan::math::integrate_ode_rk45(
           harm_osc, promote_scalar<T_y0>(y0), t0, ts,
           promote_scalar<T_theta>(theta), x, x_int, 0);
   EXPECT_NEAR(0.995029, ode_res_vd[0][0].val(), 1e-5);
@@ -141,8 +140,7 @@ TEST(StanAgradRevOde_integrate_ode_rk45, time_steps_as_param) {
   std::vector<std::vector<stan::math::var>> res;
 
   std::vector<std::vector<double>> res_d
-      = integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                           std::vector<int>>(ode, y0, t0, value_of(ts), theta,
+      = integrate_ode_rk45(ode, y0, t0, value_of(ts), theta,
                                              x, x_int);
 
   // here we only test first & last steps, and rely on the
@@ -154,32 +152,24 @@ TEST(StanAgradRevOde_integrate_ode_rk45, time_steps_as_param) {
     EXPECT_NEAR(res_d[99][0], res[99][0].val(), 1e-5);
     EXPECT_NEAR(res_d[99][1], res[99][1].val(), 1e-5);
   };
-  res = integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                           std::vector<int>>(ode, y0, t0, ts, theta, x, x_int);
+  res = integrate_ode_rk45(ode, y0, t0, ts, theta, x, x_int);
   test_val();
-  res = integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                           std::vector<int>>(ode, y0v, t0, ts, theta, x, x_int);
+  res = integrate_ode_rk45(ode, y0v, t0, ts, theta, x, x_int);
   test_val();
-  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>,
-                           std::vector<int>>(ode, y0, t0, ts, thetav, x, x_int);
+  res = integrate_ode_rk45(ode, y0, t0, ts, thetav, x, x_int);
   test_val();
-  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>,
-                           std::vector<int>>(ode, y0v, t0, ts, thetav, x,
+  res = integrate_ode_rk45(ode, y0v, t0, ts, thetav, x,
                                              x_int);
   test_val();
-  res = integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                           std::vector<int>>(ode, y0, t0v, ts, theta, x, x_int);
+  res = integrate_ode_rk45(ode, y0, t0v, ts, theta, x, x_int);
   test_val();
-  res = integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                           std::vector<int>>(ode, y0v, t0v, ts, theta, x,
+  res = integrate_ode_rk45(ode, y0v, t0v, ts, theta, x,
                                              x_int);
   test_val();
-  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>,
-                           std::vector<int>>(ode, y0, t0v, ts, thetav, x,
+  res = integrate_ode_rk45(ode, y0, t0v, ts, thetav, x,
                                              x_int);
   test_val();
-  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>,
-                           std::vector<int>>(ode, y0v, t0v, ts, thetav, x,
+  res = integrate_ode_rk45(ode, y0v, t0v, ts, thetav, x,
                                              x_int);
   test_val();
 }
@@ -222,24 +212,20 @@ TEST(StanAgradRevOde_integrate_ode_rk45, time_steps_as_param_AD) {
           } else {
             std::vector<double> y0(res_d.begin(), res_d.begin() + ns);
             EXPECT_FLOAT_EQ(g[k],
-                            ode(ts[i].val(), y0, theta, x, x_int, msgs)[j]);
+                            ode(ts[i].val(), y0, msgs, theta, x, x_int)[j]);
           }
         }
         stan::math::set_zero_all_adjoints();
       }
     }
   };
-  res = integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                           std::vector<int>>(ode, y0, t0, ts, theta, x, x_int);
+  res = integrate_ode_rk45(ode, y0, t0, ts, theta, x, x_int);
   test_ad();
-  res = integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                           std::vector<int>>(ode, y0v, t0, ts, theta, x, x_int);
+  res = integrate_ode_rk45(ode, y0v, t0, ts, theta, x, x_int);
   test_ad();
-  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>,
-                           std::vector<int>>(ode, y0, t0, ts, thetav, x, x_int);
+  res = integrate_ode_rk45(ode, y0, t0, ts, thetav, x, x_int);
   test_ad();
-  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>,
-                           std::vector<int>>(ode, y0v, t0, ts, thetav, x,
+  res = integrate_ode_rk45(ode, y0v, t0, ts, thetav, x,
                                              x_int);
   test_ad();
 }
@@ -272,26 +258,23 @@ TEST(StanAgradRevOde_integrate_ode_rk45, t0_as_param_AD) {
   auto test_ad = [&res, &t0v, &ode, &nt, &ns, &theta, &x, &x_int, &msgs]() {
     for (auto i = 0; i < nt; ++i) {
       std::vector<double> res_d = value_of(res[i]);
-      for (auto j = 0; j < ns; ++j) {
-        res[i][j].grad();
-        EXPECT_FLOAT_EQ(t0v.adj(), 0.0);
-        stan::math::set_zero_all_adjoints();
-      }
+      res[i][0].grad();
+      EXPECT_FLOAT_EQ(t0v.adj(), 0.0);
+      stan::math::set_zero_all_adjoints();
+      res[i][1].grad();
+      EXPECT_FLOAT_EQ(t0v.adj(), 1.0);
+      stan::math::set_zero_all_adjoints();
     }
   };
-  res = integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                           std::vector<int>>(ode, y0, t0v, ts, theta, x, x_int);
+  res = integrate_ode_rk45(ode, y0, t0v, ts, theta, x, x_int);
   test_ad();
-  res = integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                           std::vector<int>>(ode, y0v, t0v, ts, theta, x,
+  res = integrate_ode_rk45(ode, y0v, t0v, ts, theta, x,
                                              x_int);
   test_ad();
-  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>,
-                           std::vector<int>>(ode, y0, t0v, ts, thetav, x,
+  res = integrate_ode_rk45(ode, y0, t0v, ts, thetav, x,
                                              x_int);
   test_ad();
-  res = integrate_ode_rk45<std::vector<stan::math::var>, std::vector<double>,
-                           std::vector<int>>(ode, y0v, t0v, ts, thetav, x,
+  res = integrate_ode_rk45(ode, y0v, t0v, ts, thetav, x,
                                              x_int);
   test_ad();
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index 431726e5a3e..749538b058e 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -48,7 +48,7 @@ struct Cos2Arg {
   }
 };
 
-TEST(StanMathOde_ode_bdf, t0) {
+TEST(StanMathOde_ode_bdf_tol, t0) {
   using stan::math::var;
   
   std::vector<double> y0 = { 0.0 };
@@ -57,7 +57,7 @@ TEST(StanMathOde_ode_bdf, t0) {
 
   double a = 1.5;
   
-  std::vector<std::vector<var>> output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
+  std::vector<std::vector<var>> output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
 
   output[0][0].grad();
 
@@ -72,7 +72,7 @@ TEST(StanMathOde_ode_bdf, t0) {
   EXPECT_FLOAT_EQ(t0.adj(), -1.0);
 }
 
-TEST(StanMathOde_ode_bdf, ts) {
+TEST(StanMathOde_ode_bdf_tol, ts) {
   using stan::math::var;
   
   std::vector<double> y0 = { 0.0 };
@@ -81,7 +81,7 @@ TEST(StanMathOde_ode_bdf, ts) {
 
   double a = 1.5;
   
-  std::vector<std::vector<var>> output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
+  std::vector<std::vector<var>> output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
 
   output[0][0].grad();
 
@@ -96,7 +96,7 @@ TEST(StanMathOde_ode_bdf, ts) {
   EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
 }
 
-TEST(StanMathOde_ode_bdf, scalar_arg) {
+TEST(StanMathOde_ode_bdf_tol, scalar_arg) {
   using stan::math::var;
   
   std::vector<double> y0 = { 0.0 };
@@ -105,7 +105,7 @@ TEST(StanMathOde_ode_bdf, scalar_arg) {
 
   var a = 1.5;
   
-  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -113,7 +113,7 @@ TEST(StanMathOde_ode_bdf, scalar_arg) {
   EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_bdf, std_vector_arg) {
+TEST(StanMathOde_ode_bdf_tol, std_vector_arg) {
   using stan::math::var;
   
   std::vector<double> y0 = { 0.0 };
@@ -122,7 +122,7 @@ TEST(StanMathOde_ode_bdf, std_vector_arg) {
 
   std::vector<var> a = { 1.5 };
   
-  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -130,7 +130,7 @@ TEST(StanMathOde_ode_bdf, std_vector_arg) {
   EXPECT_FLOAT_EQ(a[0].adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_bdf, vector_arg) {
+TEST(StanMathOde_ode_bdf_tol, vector_arg) {
   using stan::math::var;
   
   std::vector<double> y0 = { 0.0 };
@@ -140,7 +140,7 @@ TEST(StanMathOde_ode_bdf, vector_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
   a << 1.5;
   
-  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -148,7 +148,7 @@ TEST(StanMathOde_ode_bdf, vector_arg) {
   EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_bdf, row_vector_arg) {
+TEST(StanMathOde_ode_bdf_tol, row_vector_arg) {
   using stan::math::var;
   
   std::vector<double> y0 = { 0.0 };
@@ -158,7 +158,7 @@ TEST(StanMathOde_ode_bdf, row_vector_arg) {
   Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
   a << 1.5;
   
-  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -166,7 +166,7 @@ TEST(StanMathOde_ode_bdf, row_vector_arg) {
   EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_bdf, matrix_arg) {
+TEST(StanMathOde_ode_bdf_tol, matrix_arg) {
   using stan::math::var;
   
   std::vector<double> y0 = { 0.0 };
@@ -176,7 +176,7 @@ TEST(StanMathOde_ode_bdf, matrix_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
   a << 1.5;
   
-  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -184,7 +184,7 @@ TEST(StanMathOde_ode_bdf, matrix_arg) {
   EXPECT_FLOAT_EQ(a(0, 0).adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_bdf, scalar_std_vector_args) {
+TEST(StanMathOde_ode_bdf_tol, scalar_std_vector_args) {
   using stan::math::var;
   
   std::vector<double> y0 = { 0.0 };
@@ -194,7 +194,7 @@ TEST(StanMathOde_ode_bdf, scalar_std_vector_args) {
   var a0 = 0.0;
   std::vector<var> a1 = { 1.5 };
   
-  var output = stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr,
+  var output = stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr,
 				   a0, a1)[0][0];
 
   output.grad();
diff --git a/test/unit/math/rev/functor/ode_rk45_prim_test.cpp b/test/unit/math/rev/functor/ode_rk45_prim_test.cpp
new file mode 100644
index 00000000000..2483066fcb5
--- /dev/null
+++ b/test/unit/math/rev/functor/ode_rk45_prim_test.cpp
@@ -0,0 +1,204 @@
+#include <stan/math/rev.hpp>
+#include <boost/numeric/odeint.hpp>
+#include <gtest/gtest.h>
+#include <test/unit/util.hpp>
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <limits>
+#include <string>
+
+template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
+T sum_(T arg) {
+  return arg;
+}
+
+template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
+auto sum_(EigMat&& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
+auto sum_(Vec&& arg) {
+  stan::scalar_type_t<Vec> sum = 0;
+  for (size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
+  }
+  return sum;
+}
+
+struct CosArg1 {
+  template <typename T0, typename T1, typename... T_Args>
+  inline std::vector<stan::return_type_t<T1, T_Args...>>
+  operator()(const T0& t, const std::vector<T1>& y,
+	     std::ostream* msgs, const T_Args&... a) const {
+
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec = { sum_(a)... };
+    return { stan::math::cos(sum_(vec) * t) };
+  }
+};
+
+struct Cos2Arg {
+  template <typename T0, typename T1, typename T2, typename T3>
+  inline std::vector<typename stan::return_type<T1, T2, T3>::type>
+  operator()(const T0& t, const std::vector<T1>& y,
+	      std::ostream* msgs, const T2& a, const T3& b) const {
+    
+    return { stan::math::cos((sum_(a) + sum_(b)) * t) };
+  }
+};
+
+TEST(StanMathOde_ode_rk45_tol, t0) {
+  using stan::math::var;
+  
+  std::vector<double> y0 = { 0.0 };
+  var t0 = 0.0;
+  std::vector<double> ts = { 0.45, 1.1 };
+
+  double a = 1.5;
+  
+  std::vector<std::vector<var>> output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+}
+
+TEST(StanMathOde_ode_rk45_tol, ts) {
+  using stan::math::var;
+  
+  std::vector<double> y0 = { 0.0 };
+  double t0 = 0.0;
+  std::vector<var> ts = { 0.45, 1.1 };
+
+  double a = 1.5;
+  
+  std::vector<std::vector<var>> output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+  
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, scalar_arg) {
+  using stan::math::var;
+  
+  std::vector<double> y0 = { 0.0 };
+  double t0 = 0.0;
+  std::vector<double> ts = { 1.1 };
+
+  var a = 1.5;
+  
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, std_vector_arg) {
+  using stan::math::var;
+  
+  std::vector<double> y0 = { 0.0 };
+  double t0 = 0.0;
+  std::vector<double> ts = { 1.1 };
+
+  std::vector<var> a = { 1.5 };
+  
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a[0].adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, vector_arg) {
+  using stan::math::var;
+  
+  std::vector<double> y0 = { 0.0 };
+  double t0 = 0.0;
+  std::vector<double> ts = { 1.1 };
+
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
+  a << 1.5;
+  
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, row_vector_arg) {
+  using stan::math::var;
+  
+  std::vector<double> y0 = { 0.0 };
+  double t0 = 0.0;
+  std::vector<double> ts = { 1.1 };
+
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
+  a << 1.5;
+  
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, matrix_arg) {
+  using stan::math::var;
+  
+  std::vector<double> y0 = { 0.0 };
+  double t0 = 0.0;
+  std::vector<double> ts = { 1.1 };
+
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
+  a << 1.5;
+  
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0, 0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, scalar_std_vector_args) {
+  using stan::math::var;
+  
+  std::vector<double> y0 = { 0.0 };
+  double t0 = 0.0;
+  std::vector<double> ts = { 1.1 };
+
+  var a0 = 0.0;
+  std::vector<var> a1 = { 1.5 };
+  
+  var output = stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr,
+				   a0, a1)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
+}
diff --git a/test/unit/math/rev/functor/util.hpp b/test/unit/math/rev/functor/util.hpp
index 14ebfb52d5c..7461ee747d1 100644
--- a/test/unit/math/rev/functor/util.hpp
+++ b/test/unit/math/rev/functor/util.hpp
@@ -30,12 +30,10 @@ std::vector<std::vector<double>> finite_diff_params(
   std::vector<std::vector<double>> ode_res_lb;
 
   ode_res_ub
-      = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(
+      = stan::math::integrate_ode_rk45(
           f, y_in, t_in, ts, theta_ub, x, x_int, &msgs);
   ode_res_lb
-      = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(
+      = stan::math::integrate_ode_rk45(
           f, y_in, t_in, ts, theta_lb, x, x_int, &msgs);
 
   std::vector<std::vector<double>> results(ts.size());
@@ -70,12 +68,10 @@ std::vector<std::vector<double>> finite_diff_initial_position(
   std::vector<std::vector<double>> ode_res_lb;
 
   ode_res_ub
-      = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(
+      = stan::math::integrate_ode_rk45(
           f, y_in_ub, t_in, ts, theta, x, x_int, &msgs);
   ode_res_lb
-      = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(
+      = stan::math::integrate_ode_rk45(
           f, y_in_lb, t_in, ts, theta, x, x_int, &msgs);
 
   std::vector<std::vector<double>> results(ts.size());
@@ -112,8 +108,7 @@ void test_ode_finite_diff_dv(const F& f, const double& t_in,
   std::vector<std::vector<stan::math::var>> ode_res;
 
   ode_res
-      = stan::math::integrate_ode_rk45<std::vector<stan::math::var>,
-                                       std::vector<double>, std::vector<int>>(
+      = stan::math::integrate_ode_rk45(
           f, y_in, t_in, ts, theta_v, x, x_int, &msgs);
 
   for (size_t i = 0; i < ts.size(); i++) {
@@ -158,8 +153,7 @@ void test_ode_finite_diff_vd(const F& f, const double& t_in,
   std::vector<std::vector<stan::math::var>> ode_res;
 
   ode_res
-      = stan::math::integrate_ode_rk45<std::vector<double>, std::vector<double>,
-                                       std::vector<int>>(
+      = stan::math::integrate_ode_rk45(
           f, y_in_v, t_in, ts, theta, x, x_int, &msgs);
 
   for (size_t i = 0; i < ts.size(); i++) {
@@ -217,8 +211,7 @@ void test_ode_finite_diff_vv(const F& f, const double& t_in,
   std::vector<std::vector<stan::math::var>> ode_res;
 
   ode_res
-      = stan::math::integrate_ode_rk45<std::vector<stan::math::var>,
-                                       std::vector<double>, std::vector<int>>(
+      = stan::math::integrate_ode_rk45(
           f, y_in_v, t_in, ts, theta_v, x, x_int, &msgs);
 
   for (size_t i = 0; i < ts.size(); i++) {
@@ -255,14 +248,12 @@ void test_ode_error_conditions(F& f, const double& t0,
   std::stringstream msgs;
 
   ASSERT_NO_THROW((
-      integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                         std::vector<int>>(f, y0, t0, ts, theta, x, x_int, 0)));
+      integrate_ode_rk45(f, y0, t0, ts, theta, x, x_int, 0)));
   ASSERT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T1> y0_bad;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
                    std::invalid_argument, "initial state has size 0");
   EXPECT_EQ("", msgs.str());
@@ -272,16 +263,14 @@ void test_ode_error_conditions(F& f, const double& t0,
   std::stringstream expected_msg;
   expected_msg << "initial time is " << t0_bad << ", but must be less than "
                << ts[0];
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
                    std::domain_error, expected_msg.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<double> ts_bad;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
                    std::invalid_argument, "times has size 0");
   EXPECT_EQ("", msgs.str());
@@ -289,16 +278,14 @@ void test_ode_error_conditions(F& f, const double& t0,
   msgs.clear();
   ts_bad.push_back(3);
   ts_bad.push_back(1);
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
                    std::domain_error, "times is not a valid ordered vector");
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T2> theta_bad;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
                    std::out_of_range, "vector");
   EXPECT_EQ("", msgs.str());
@@ -306,8 +293,7 @@ void test_ode_error_conditions(F& f, const double& t0,
   if (x.size() > 0) {
     msgs.clear();
     std::vector<double> x_bad;
-    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                         std::vector<int>>(
+    EXPECT_THROW_MSG((integrate_ode_rk45(
                          f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
                      std::out_of_range, "vector");
     EXPECT_EQ("", msgs.str());
@@ -316,8 +302,7 @@ void test_ode_error_conditions(F& f, const double& t0,
   if (x_int.size() > 0) {
     msgs.clear();
     std::vector<int> x_int_bad;
-    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                         std::vector<int>>(
+    EXPECT_THROW_MSG((integrate_ode_rk45(
                          f, y0, t0, ts, theta, x, x_int_bad, &msgs)),
                      std::out_of_range, "vector");
     EXPECT_EQ("", msgs.str());
@@ -338,31 +323,26 @@ void test_ode_error_conditions_nan(F& f, const double& t0,
   expected_is_nan << "is " << nan;
 
   ASSERT_NO_THROW((
-      integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                         std::vector<int>>(f, y0, t0, ts, theta, x, x_int, 0)));
+      integrate_ode_rk45(f, y0, t0, ts, theta, x, x_int, 0)));
   ASSERT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T1> y0_bad = y0;
   y0_bad[0] = nan;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
                    std::domain_error, "initial state");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
                    std::domain_error, expected_is_nan.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   double t0_bad = nan;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
                    std::domain_error, "initial time");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
                    std::domain_error, expected_is_nan.str());
   EXPECT_EQ("", msgs.str());
@@ -370,12 +350,10 @@ void test_ode_error_conditions_nan(F& f, const double& t0,
   msgs.clear();
   std::vector<double> ts_bad = ts;
   ts_bad[0] = nan;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
                    std::domain_error, "times");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
                    std::domain_error, expected_is_nan.str());
   EXPECT_EQ("", msgs.str());
@@ -383,12 +361,10 @@ void test_ode_error_conditions_nan(F& f, const double& t0,
   msgs.clear();
   std::vector<T2> theta_bad = theta;
   theta_bad[0] = nan;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
                    std::domain_error, "ode parameters and data");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
                    std::domain_error, expected_is_nan.str());
   EXPECT_EQ("", msgs.str());
@@ -397,12 +373,10 @@ void test_ode_error_conditions_nan(F& f, const double& t0,
     msgs.clear();
     std::vector<double> x_bad = x;
     x_bad[0] = nan;
-    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                         std::vector<int>>(
+    EXPECT_THROW_MSG((integrate_ode_rk45(
                          f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
                      std::domain_error, "ode parameters and data");
-    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                         std::vector<int>>(
+    EXPECT_THROW_MSG((integrate_ode_rk45(
                          f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
                      std::domain_error, expected_is_nan.str());
     EXPECT_EQ("", msgs.str());
@@ -425,49 +399,40 @@ void test_ode_error_conditions_inf(F& f, const double& t0,
   expected_is_neg_inf << "is " << -inf;
 
   ASSERT_NO_THROW((
-      integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                         std::vector<int>>(f, y0, t0, ts, theta, x, x_int, 0)));
+      integrate_ode_rk45(f, y0, t0, ts, theta, x, x_int, 0)));
   ASSERT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T1> y0_bad = y0;
   y0_bad[0] = inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
                    std::domain_error, "initial state");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
                    std::domain_error, expected_is_inf.str());
   y0_bad[0] = -inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
                    std::domain_error, "initial state");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
                    std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   double t0_bad = inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
                    std::domain_error, "initial time");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
                    std::domain_error, expected_is_inf.str());
   t0_bad = -inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
                    std::domain_error, "initial time");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
                    std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
@@ -475,21 +440,17 @@ void test_ode_error_conditions_inf(F& f, const double& t0,
   msgs.clear();
   std::vector<double> ts_bad = ts;
   ts_bad[0] = inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
                    std::domain_error, "times");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
                    std::domain_error, expected_is_inf.str());
   ts_bad[0] = -inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
                    std::domain_error, "times");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
                    std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
@@ -497,21 +458,17 @@ void test_ode_error_conditions_inf(F& f, const double& t0,
   msgs.clear();
   std::vector<T2> theta_bad = theta;
   theta_bad[0] = inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
                    std::domain_error, "ode parameters and data");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
                    std::domain_error, expected_is_inf.str());
   theta_bad[0] = -inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
                    std::domain_error, "ode parameters and data");
-  EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                       std::vector<int>>(
+  EXPECT_THROW_MSG((integrate_ode_rk45(
                        f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
                    std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
@@ -520,21 +477,17 @@ void test_ode_error_conditions_inf(F& f, const double& t0,
     msgs.clear();
     std::vector<double> x_bad = x;
     x_bad[0] = inf;
-    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                         std::vector<int>>(
+    EXPECT_THROW_MSG((integrate_ode_rk45(
                          f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
                      std::domain_error, "ode parameters and data");
-    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                         std::vector<int>>(
+    EXPECT_THROW_MSG((integrate_ode_rk45(
                          f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
                      std::domain_error, expected_is_inf.str());
     x_bad[0] = -inf;
-    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                         std::vector<int>>(
+    EXPECT_THROW_MSG((integrate_ode_rk45(
                          f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
                      std::domain_error, "ode parameters and data");
-    EXPECT_THROW_MSG((integrate_ode_rk45<std::vector<T2>, std::vector<double>,
-                                         std::vector<int>>(
+    EXPECT_THROW_MSG((integrate_ode_rk45(
                          f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
                      std::domain_error, expected_is_neg_inf.str());
     EXPECT_EQ("", msgs.str());

From 085c3bcbca4b56caeff6e7c0415a7ab72f9b7d52 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 13 Apr 2020 10:29:34 -0400
Subject: [PATCH 103/189] [Jenkins] auto-formatting by clang-format version
 6.0.0

---
 .../math/prim/fun/ode_store_sensitivities.hpp |  12 +-
 stan/math/prim/functor/coupled_ode_system.hpp |  31 +-
 stan/math/prim/functor/integrate_ode_rk45.hpp |  27 +-
 stan/math/prim/functor/ode_rk45.hpp           |  32 +--
 stan/math/rev/fun/ode_store_sensitivities.hpp |  22 +-
 stan/math/rev/functor/coupled_ode_rhs.hpp     |  41 +--
 stan/math/rev/functor/coupled_ode_system.hpp  |  31 +-
 stan/math/rev/functor/cvodes_integrator.hpp   |  94 ++++---
 stan/math/rev/functor/integrate_ode_bdf.hpp   |   7 +-
 .../rev/functor/ode_add_time_gradients.hpp    |  51 ++--
 stan/math/rev/functor/ode_bdf.hpp             |  44 ++-
 stan/math/rev/functor/ode_rk45.hpp            |  42 ++-
 .../functor/forced_harmonic_oscillator.hpp    |   3 +-
 .../math/prim/functor/harmonic_oscillator.hpp |  12 +-
 .../functor/integrate_ode_rk45_prim_test.cpp  | 203 +++++++------
 test/unit/math/prim/functor/lorenz.hpp        |   3 +-
 .../functor/integrate_ode_bdf_rev_test.cpp    |   4 +-
 .../functor/integrate_ode_rk45_rev_test.cpp   |  34 +--
 .../math/rev/functor/ode_bdf_prim_test.cpp    |  66 +++--
 .../math/rev/functor/ode_rk45_prim_test.cpp   | 116 ++++----
 test/unit/math/rev/functor/util.hpp           | 266 +++++++++---------
 21 files changed, 564 insertions(+), 577 deletions(-)

diff --git a/stan/math/prim/fun/ode_store_sensitivities.hpp b/stan/math/prim/fun/ode_store_sensitivities.hpp
index 5c2e6599db3..06e57c8d804 100644
--- a/stan/math/prim/fun/ode_store_sensitivities.hpp
+++ b/stan/math/prim/fun/ode_store_sensitivities.hpp
@@ -8,11 +8,13 @@
 namespace stan {
 namespace math {
 
-template <typename... Args, typename = require_all_arithmetic_t<scalar_type_t<Args>...>>
-std::vector<double> ode_store_sensitivities(const std::vector<double>& coupled_state,
-					    const std::vector<double>& y0,
-					    const Args&... args) {
-  return std::vector<double>(coupled_state.data(), coupled_state.data() + y0.size());
+template <typename... Args,
+          typename = require_all_arithmetic_t<scalar_type_t<Args>...>>
+std::vector<double> ode_store_sensitivities(
+    const std::vector<double>& coupled_state, const std::vector<double>& y0,
+    const Args&... args) {
+  return std::vector<double>(coupled_state.data(),
+                             coupled_state.data() + y0.size());
 }
 
 }  // namespace math
diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
index 2c331008785..94e61288283 100644
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -62,7 +62,7 @@ namespace math {
 
 template <bool Enable, typename F, typename T_initial, typename... Args>
 struct coupled_ode_system_impl;
-  
+
 template <typename F, typename T_initial, typename... Args>
 struct coupled_ode_system_impl<true, F, T_initial, Args...> {
   const F& f_;
@@ -84,19 +84,13 @@ struct coupled_ode_system_impl<true, F, T_initial, Args...> {
    * @param[in, out] msgs stream for messages
    */
   coupled_ode_system_impl(const F& f, const std::vector<double>& y0,
-			  std::ostream* msgs, const Args&... args)
-      : f_(f),
-        y0_(y0),
-	args_tuple_(args...),
-        N_(y0.size()),
-        msgs_(msgs) {
-  }
+                          std::ostream* msgs, const Args&... args)
+      : f_(f), y0_(y0), args_tuple_(args...), N_(y0.size()), msgs_(msgs) {}
 
   void operator()(const std::vector<double>& y, std::vector<double>& dy_dt,
                   double t) const {
-    dy_dt = apply([&](const Args&... args) {
-	return f_(t, y, msgs_, args...);
-      }, args_tuple_);
+    dy_dt = apply([&](const Args&... args) { return f_(t, y, msgs_, args...); },
+                  args_tuple_);
 
     check_size_match("coupled_ode_system", "y", y.size(), "dy_dt",
                      dy_dt.size());
@@ -131,14 +125,15 @@ struct coupled_ode_system_impl<true, F, T_initial, Args...> {
 };
 
 template <typename F, typename T_initial, typename... Args>
-struct coupled_ode_system :
-    public coupled_ode_system_impl<std::is_arithmetic<return_type_t<T_initial, Args...>>::value,
-				   F, T_initial, Args...> {
-
+struct coupled_ode_system
+    : public coupled_ode_system_impl<
+          std::is_arithmetic<return_type_t<T_initial, Args...>>::value, F,
+          T_initial, Args...> {
   coupled_ode_system(const F& f, const std::vector<T_initial>& y0,
-		     std::ostream* msgs, const Args&... args)
-    : coupled_ode_system_impl<std::is_arithmetic<return_type_t<T_initial, Args...>>::value,
-			      F, T_initial, Args...>(f, y0, msgs, args...) {}
+                     std::ostream* msgs, const Args&... args)
+      : coupled_ode_system_impl<
+            std::is_arithmetic<return_type_t<T_initial, Args...>>::value, F,
+            T_initial, Args...>(f, y0, msgs, args...) {}
 };
 
 }  // namespace math
diff --git a/stan/math/prim/functor/integrate_ode_rk45.hpp b/stan/math/prim/functor/integrate_ode_rk45.hpp
index 829a3eabcbc..947d8f1b36b 100644
--- a/stan/math/prim/functor/integrate_ode_rk45.hpp
+++ b/stan/math/prim/functor/integrate_ode_rk45.hpp
@@ -56,21 +56,18 @@ namespace math {
  * same size as the state variable, corresponding to a time in ts.
  */
 
-template <typename F, typename T1, typename T_param, typename T_t0, typename T_ts>
-std::vector<std::vector<return_type_t<T1, T_t0, T_ts, T_param>>> integrate_ode_rk45(
-    const F& f, const std::vector<T1>& y0, const T_t0& t0,
-    const std::vector<T_ts>& ts,
-    const std::vector<T_param>& theta,
-    const std::vector<double>& x, const std::vector<int>& x_int,
-    std::ostream* msgs = nullptr,
-    double relative_tolerance = 1e-6,
-    double absolute_tolerance = 1e-6,
-    int max_num_steps = 1e6) {
-  return ode_rk45_tol(f, y0, t0, ts,
-		      relative_tolerance, absolute_tolerance,
-		      max_num_steps,
-		      msgs,
-		      theta, x, x_int);
+template <typename F, typename T1, typename T_param, typename T_t0,
+          typename T_ts>
+std::vector<std::vector<return_type_t<T1, T_t0, T_ts, T_param>>>
+integrate_ode_rk45(const F& f, const std::vector<T1>& y0, const T_t0& t0,
+                   const std::vector<T_ts>& ts,
+                   const std::vector<T_param>& theta,
+                   const std::vector<double>& x, const std::vector<int>& x_int,
+                   std::ostream* msgs = nullptr,
+                   double relative_tolerance = 1e-6,
+                   double absolute_tolerance = 1e-6, int max_num_steps = 1e6) {
+  return ode_rk45_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
+                      max_num_steps, msgs, theta, x, x_int);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index 173bcd09438..86d3b68865f 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -13,32 +13,23 @@ namespace math {
 
 template <typename F, typename T_initial, typename... Args>
 std::vector<std::vector<typename stan::return_type<T_initial, Args...>::type>>
-ode_rk45(const F& f, const std::vector<T_initial>& y0,
-	 double t0,
-	 const std::vector<double>& ts,
-	 std::ostream* msgs,
-	 const Args&... args) {
+ode_rk45(const F& f, const std::vector<T_initial>& y0, double t0,
+         const std::vector<double>& ts, std::ostream* msgs,
+         const Args&... args) {
   double relative_tolerance = 1e-6;
   double absolute_tolerance = 1e-6;
   long int max_num_steps = 1e6;
 
-  return ode_rk45_tol(f, y0, t0, ts,
-		      relative_tolerance, absolute_tolerance,
-		      max_num_steps,
-		      msgs,
-		      args...);
+  return ode_rk45_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
+                      max_num_steps, msgs, args...);
 }
 
 template <typename F, typename T_initial, typename... Args>
 std::vector<std::vector<typename stan::return_type<T_initial, Args...>::type>>
-ode_rk45_tol(const F& f, const std::vector<T_initial>& y0,
-	     double t0,
-	     const std::vector<double>& ts,
-	     double relative_tolerance,
-	     double absolute_tolerance,
-	     long int max_num_steps,
-	     std::ostream* msgs,
-	     const Args&... args) {
+ode_rk45_tol(const F& f, const std::vector<T_initial>& y0, double t0,
+             const std::vector<double>& ts, double relative_tolerance,
+             double absolute_tolerance, long int max_num_steps,
+             std::ostream* msgs, const Args&... args) {
   using boost::numeric::odeint::integrate_times;
   using boost::numeric::odeint::make_dense_output;
   using boost::numeric::odeint::max_step_checker;
@@ -75,7 +66,8 @@ ode_rk45_tol(const F& f, const std::vector<T_initial>& y0,
 
   using return_t = return_type_t<T_initial, Args...>;
   // creates basic or coupled system by template specializations
-  coupled_ode_system<F, T_initial, Args...> coupled_system(f, y0, msgs, args...);
+  coupled_ode_system<F, T_initial, Args...> coupled_system(f, y0, msgs,
+                                                           args...);
 
   // first time in the vector must be time of initial state
   std::vector<double> ts_vec(ts.size() + 1);
@@ -85,7 +77,7 @@ ode_rk45_tol(const F& f, const std::vector<T_initial>& y0,
   std::vector<std::vector<return_t>> y;
   bool observer_initial_recorded = false;
   size_t time_index = 0;
-  
+
   // avoid recording of the initial state which is included by the
   // conventions of odeint in the output
   auto filtered_observer
diff --git a/stan/math/rev/fun/ode_store_sensitivities.hpp b/stan/math/rev/fun/ode_store_sensitivities.hpp
index 47448d94bd2..6ad16e145c8 100644
--- a/stan/math/rev/fun/ode_store_sensitivities.hpp
+++ b/stan/math/rev/fun/ode_store_sensitivities.hpp
@@ -10,24 +10,25 @@ namespace stan {
 namespace math {
 
 template <typename T_initial, typename... Args>
-std::vector<var> ode_store_sensitivities(const std::vector<double>& coupled_state,
-					 const std::vector<T_initial>& y0,
-					 const Args&... args) {
+std::vector<var> ode_store_sensitivities(
+    const std::vector<double>& coupled_state, const std::vector<T_initial>& y0,
+    const Args&... args) {
   const size_t N = y0.size();
   const size_t y0_vars = count_vars(y0);
   const size_t args_vars = count_vars(args...);
   std::vector<var> yt;
-    
+
   for (size_t j = 0; j < N; j++) {
     const size_t total_vars = y0_vars + args_vars;
 
-    vari** varis = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
-    double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(total_vars);
+    vari** varis
+        = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
+    double* partials
+        = ChainableStack::instance_->memalloc_.alloc_array<double>(total_vars);
 
     vari** varis_ptr = varis;
     double* partials_ptr = partials;
 
-
     // iterate over parameters for each equation
     varis_ptr = save_varis(varis_ptr, y0);
     for (std::size_t k = 0; k < y0_vars; k++) {
@@ -44,13 +45,14 @@ std::vector<var> ode_store_sensitivities(const std::vector<double>& coupled_stat
       partials_ptr++;
     }
 
-    yt.emplace_back(new precomputed_gradients_vari(coupled_state[j], total_vars, varis, partials));
+    yt.emplace_back(new precomputed_gradients_vari(coupled_state[j], total_vars,
+                                                   varis, partials));
   }
 
   return yt;
 }
 
-} // namespace math
-} // namespace stan
+}  // namespace math
+}  // namespace stan
 
 #endif
diff --git a/stan/math/rev/functor/coupled_ode_rhs.hpp b/stan/math/rev/functor/coupled_ode_rhs.hpp
index f2d43ae6576..8ee6e728615 100644
--- a/stan/math/rev/functor/coupled_ode_rhs.hpp
+++ b/stan/math/rev/functor/coupled_ode_rhs.hpp
@@ -12,11 +12,10 @@ namespace math {
 
 namespace internal {
 template <typename F, typename T_y, typename... Args>
-std::vector<double> coupled_ode_rhs(const F& f,
-				    double t,
-				    const std::vector<T_y>& y,
-				    std::ostream* msgs,
-				    const Args&... args) const {
+std::vector<double> coupled_ode_rhs(const F& f, double t,
+                                    const std::vector<T_y>& y,
+                                    std::ostream* msgs,
+                                    const Args&... args) const {
   // Run nested autodiff in this scope
   nested_rev_autodiff nested;
 
@@ -25,14 +24,14 @@ std::vector<double> coupled_ode_rhs(const F& f,
   const size_t args_vars = count_vars(args...);
   std::vector<double> dz_dt(N + N * y_vars + N * args_vars);
   const std::vector<var> y_vars(y.begin(), y.end());
-  std::tuple<decltype(deep_copy_vars(args))...> local_args_tuple(deep_copy_vars(args)...);
-    
-  std::vector<var> dy_dt_vars = apply([&](auto&&... args) {
-      f_(t, y_vars, msgs_, args...);
-    }, local_args_tuple);
+  std::tuple<decltype(deep_copy_vars(args))...> local_args_tuple(
+      deep_copy_vars(args)...);
+
+  std::vector<var> dy_dt_vars = apply(
+      [&](auto&&... args) { f_(t, y_vars, msgs_, args...); }, local_args_tuple);
 
   check_size_match("coupled_ode_system", "dy_dt", dy_dt_vars.size(), "states",
-		   N);
+                   N);
 
   for (size_t i = 0; i < N; ++i) {
     dz_dt[i] = dy_dt_vars[i].val();
@@ -45,26 +44,28 @@ std::vector<double> coupled_ode_rhs(const F& f,
       double temp_deriv = 0;
       const size_t offset = N + N * j;
       for (size_t k = 0; k < N; k++) {
-	temp_deriv += z[N + N * j + k] * y_vars[k].adj();
+        temp_deriv += z[N + N * j + k] * y_vars[k].adj();
       }
-	
+
       dz_dt[N + N * j + i] = temp_deriv;
     }
-      
+
     Eigen::VectorXd args_adjoints = Eigen::VectorXd::Zero(args_vars);
-    apply([&](auto&&... args) {
-	accumulate_adjoints(args_adjoints.data(), args...);
-      }, local_args_tuple);
+    apply(
+        [&](auto&&... args) {
+          accumulate_adjoints(args_adjoints.data(), args...);
+        },
+        local_args_tuple);
 
     for (size_t j = 0; j < args_vars; j++) {
       double temp_deriv = args_adjoints(j);
       for (size_t k = 0; k < N; k++) {
-	temp_deriv += z[N + N * y0_vars + N * j + k] * y_vars[k].adj();
+        temp_deriv += z[N + N * y0_vars + N * j + k] * y_vars[k].adj();
       }
-	
+
       dz_dt[N + N * y0_vars + N * j + i] = temp_deriv;
     }
-      
+
     nested.set_zero_all_adjoints();
   }
 }
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index de714cf3faf..d4d897f8025 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -84,10 +84,8 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
    * @param[in] x_int integer data
    * @param[in, out] msgs stream for messages
    */
-  coupled_ode_system_impl(const F& f,
-			  const std::vector<T_initial>& y0,
-			  std::ostream* msgs,
-			  const Args&... args)
+  coupled_ode_system_impl(const F& f, const std::vector<T_initial>& y0,
+                          std::ostream* msgs, const Args&... args)
       : f_(f),
         y0_(y0),
         args_tuple_(args...),
@@ -118,13 +116,16 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
     nested_rev_autodiff nested;
 
     const vector<var> y_vars(z.begin(), z.begin() + N_);
-    auto local_args_tuple = apply([&](auto&&... args) {
-      return std::tuple<decltype(deep_copy_vars(args))...>(deep_copy_vars(args)...);
-      }, args_tuple_);
-    
-    vector<var> f_y_t_vars = apply(
-      [&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
-      local_args_tuple);
+    auto local_args_tuple = apply(
+        [&](auto&&... args) {
+          return std::tuple<decltype(deep_copy_vars(args))...>(
+              deep_copy_vars(args)...);
+        },
+        args_tuple_);
+
+    vector<var> f_y_t_vars
+        = apply([&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
+                local_args_tuple);
 
     check_size_match("coupled_ode_system", "dy_dt", f_y_t_vars.size(), "states",
                      N_);
@@ -147,10 +148,10 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
 
       Eigen::VectorXd args_adjoints = Eigen::VectorXd::Zero(args_vars_);
       apply(
-	    [&](auto&&... args) {
-	      accumulate_adjoints(args_adjoints.data(), args...);
-	    },
-	    local_args_tuple);
+          [&](auto&&... args) {
+            accumulate_adjoints(args_adjoints.data(), args...);
+          },
+          local_args_tuple);
       for (size_t j = 0; j < args_vars_; j++) {
         double temp_deriv = args_adjoints(j);
         for (size_t k = 0; k < N_; k++) {
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 28cda912ec4..67243af78e1 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -22,8 +22,7 @@ namespace math {
  *
  * @tparam Lmm ID of ODE solver (1: ADAMS, 2: BDF)
  */
-template <int Lmm, typename F, typename T_initial,
-	  typename... T_Args>
+template <int Lmm, typename F, typename T_initial, typename... T_Args>
 class cvodes_integrator {
   using T_Return = return_type_t<T_initial, T_Args...>;
 
@@ -95,11 +94,11 @@ class cvodes_integrator {
    */
   inline void rhs(double t, const double y[], double dy_dt[]) const {
     const std::vector<double> y_vec(y, y + N_);
-    std::vector<double> dy_dt_vec = apply([&](auto&&... args) {
-	return f_(t, y_vec, msgs_, args...);
-      }, value_of_args_tuple_);
-    check_size_match("cvodes_integrator::rhs", "dy_dt", dy_dt_vec.size(), "states",
-                     N_);
+    std::vector<double> dy_dt_vec
+        = apply([&](auto&&... args) { return f_(t, y_vec, msgs_, args...); },
+                value_of_args_tuple_);
+    check_size_match("cvodes_integrator::rhs", "dy_dt", dy_dt_vec.size(),
+                     "states", N_);
     std::move(dy_dt_vec.begin(), dy_dt_vec.end(), dy_dt);
   }
 
@@ -112,16 +111,16 @@ class cvodes_integrator {
     Eigen::MatrixXd Jfy;
 
     auto f_wrapped = [&](const Eigen::Matrix<var, Eigen::Dynamic, 1>& y) {
-      return to_vector(apply([&](auto&&... args) {
-	    return f_(t, to_array_1d(y), msgs_, args...);
-	  }, value_of_args_tuple_));
+      return to_vector(apply(
+          [&](auto&&... args) { return f_(t, to_array_1d(y), msgs_, args...); },
+          value_of_args_tuple_));
     };
-    
+
     jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(y, N_), fy, Jfy);
 
-    for(size_t j = 0; j < Jfy.cols(); ++j) {
-      for(size_t i = 0; i < Jfy.rows(); ++i) {
-	SM_ELEMENT_D(J, i, j) = Jfy(i, j);
+    for (size_t j = 0; j < Jfy.cols(); ++j) {
+      for (size_t i = 0; i < Jfy.rows(); ++i) {
+        SM_ELEMENT_D(J, i, j) = Jfy(i, j);
       }
     }
   }
@@ -148,30 +147,26 @@ class cvodes_integrator {
     }
   }
 
-public:
-  cvodes_integrator(const F& f,
-		    const std::vector<T_initial>& y0,
-		    double t0,
-		    const std::vector<double>& ts,
-		    double relative_tolerance,
-		    double absolute_tolerance,
-		    long int max_num_steps,
-		    std::ostream* msgs, const T_Args&... args)
-    : f_(f),
-      y0_(y0),
-      t0_(t0),
-      ts_(ts),
-      args_tuple_(args...),
-      value_of_args_tuple_(value_of(args)...),
-      N_(y0.size()),
-      msgs_(msgs),
-      relative_tolerance_(relative_tolerance),
-      absolute_tolerance_(absolute_tolerance),
-      max_num_steps_(max_num_steps),
-      y0_vars_(count_vars(y0_)),
-      args_vars_(count_vars(args...)),
-      coupled_ode_(f, y0, msgs, args...),
-      coupled_state_(coupled_ode_.initial_state()) {
+ public:
+  cvodes_integrator(const F& f, const std::vector<T_initial>& y0, double t0,
+                    const std::vector<double>& ts, double relative_tolerance,
+                    double absolute_tolerance, long int max_num_steps,
+                    std::ostream* msgs, const T_Args&... args)
+      : f_(f),
+        y0_(y0),
+        t0_(t0),
+        ts_(ts),
+        args_tuple_(args...),
+        value_of_args_tuple_(value_of(args)...),
+        N_(y0.size()),
+        msgs_(msgs),
+        relative_tolerance_(relative_tolerance),
+        absolute_tolerance_(absolute_tolerance),
+        max_num_steps_(max_num_steps),
+        y0_vars_(count_vars(y0_)),
+        args_vars_(count_vars(args...)),
+        coupled_ode_(f, y0, msgs, args...),
+        coupled_state_(coupled_ode_.initial_state()) {
     using initial_var = stan::is_var<T_initial>;
 
     const char* fun = "cvodes_integrator::integrate";
@@ -180,10 +175,14 @@ class cvodes_integrator {
     check_finite(fun, "initial time", t0_);
     check_finite(fun, "times", ts_);
 
-    // Code from: https://stackoverflow.com/a/17340003 . Should probably do something better
-    apply([&](auto&&... args) {
-	std::vector<int> unused_temp{ 0, (check_finite(fun, "ode parameters and data", args), 0)... };
-      }, args_tuple_);
+    // Code from: https://stackoverflow.com/a/17340003 . Should probably do
+    // something better
+    apply(
+        [&](auto&&... args) {
+          std::vector<int> unused_temp{
+              0, (check_finite(fun, "ode parameters and data", args), 0)...};
+        },
+        args_tuple_);
 
     check_nonzero_size(fun, "times", ts_);
     check_nonzero_size(fun, "initial state", y0_);
@@ -199,7 +198,8 @@ class cvodes_integrator {
     LS_ = SUNDenseLinearSolver(nv_state_, A_);
 
     if (y0_vars_ + args_vars_ > 0) {
-      nv_state_sens_ = N_VCloneVectorArrayEmpty_Serial(y0_vars_ + args_vars_, nv_state_);
+      nv_state_sens_
+          = N_VCloneVectorArrayEmpty_Serial(y0_vars_ + args_vars_, nv_state_);
       for (std::size_t i = 0; i < y0_vars_ + args_vars_; i++) {
         NV_DATA_S(nv_state_sens_[i]) = &coupled_state_[N_] + i * N_;
       }
@@ -316,9 +316,11 @@ class cvodes_integrator {
                               "CVodeGetSens");
         }
 
-	y.emplace_back(apply([&](auto&&... args) {
-	      return ode_store_sensitivities(coupled_state_, y0_, args...);
-	    }, args_tuple_));
+        y.emplace_back(apply(
+            [&](auto&&... args) {
+              return ode_store_sensitivities(coupled_state_, y0_, args...);
+            },
+            args_tuple_));
 
         t_init = t_final;
       }
diff --git a/stan/math/rev/functor/integrate_ode_bdf.hpp b/stan/math/rev/functor/integrate_ode_bdf.hpp
index 29c3b081c5f..6dd52ecdee6 100644
--- a/stan/math/rev/functor/integrate_ode_bdf.hpp
+++ b/stan/math/rev/functor/integrate_ode_bdf.hpp
@@ -19,11 +19,8 @@ integrate_ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
                   double relative_tolerance = 1e-10,
                   double absolute_tolerance = 1e-10,
                   long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
-  return ode_bdf_tol(f, y0, t0, ts,
-		     relative_tolerance, absolute_tolerance,
-		     max_num_steps,
-		     msgs,
-		     theta, x, x_int);
+  return ode_bdf_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
+                     max_num_steps, msgs, theta, x, x_int);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/ode_add_time_gradients.hpp b/stan/math/rev/functor/ode_add_time_gradients.hpp
index f770153db2e..dfac7e5c75a 100644
--- a/stan/math/rev/functor/ode_add_time_gradients.hpp
+++ b/stan/math/rev/functor/ode_add_time_gradients.hpp
@@ -10,58 +10,53 @@ namespace stan {
 namespace math {
 namespace internal {
 double ode_time_gradient_var(double t, double grad) {
-  invalid_argument("ode_time_gradient_var", "t", t, "t must be of type var, not double");
+  invalid_argument("ode_time_gradient_var", "t", t,
+                   "t must be of type var, not double");
   return 0.0;
 }
 
 var ode_time_gradient_var(var t, double grad) {
   return var(new precomp_v_vari(0.0, t.vi_, grad));
 }
-}; // namespace internal
+};  // namespace internal
 
-template <typename F, typename T_initial,
-	  typename T_out, typename... T_Args>
-auto ode_add_time_gradients(const F& f,
-			    const std::vector<T_initial>& y0,
-			    double t0,
-			    const std::vector<double>& ts,
-			    const std::vector<std::vector<T_out>>& y,
-			    std::ostream* msgs,
-			    const T_Args&... args) {
+template <typename F, typename T_initial, typename T_out, typename... T_Args>
+auto ode_add_time_gradients(const F& f, const std::vector<T_initial>& y0,
+                            double t0, const std::vector<double>& ts,
+                            const std::vector<std::vector<T_out>>& y,
+                            std::ostream* msgs, const T_Args&... args) {
   return y;
 }
 
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
-	  typename T_out, typename... T_Args>
-std::vector<std::vector<var>> ode_add_time_gradients(const F& f,
-						     const std::vector<T_initial>& y0,
-						     const T_t0& t0,
-						     const std::vector<T_ts>& ts,
-						     const std::vector<std::vector<T_out>>& y,
-						     std::ostream* msgs,
-						     const T_Args&... args) {
+          typename T_out, typename... T_Args>
+std::vector<std::vector<var>> ode_add_time_gradients(
+    const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
+    const std::vector<T_ts>& ts, const std::vector<std::vector<T_out>>& y,
+    std::ostream* msgs, const T_Args&... args) {
   std::vector<double> f_y0_t0 = {};
-  if(is_var<T_t0>::value) {
+  if (is_var<T_t0>::value) {
     f_y0_t0 = f(value_of(t0), value_of(y0), msgs, value_of(args)...);
 
-    check_size_match("coupled_ode_observer", "dy_dt", f_y0_t0.size(), "states", y0.size());
+    check_size_match("coupled_ode_observer", "dy_dt", f_y0_t0.size(), "states",
+                     y0.size());
   }
 
   std::vector<std::vector<var>> y_with_gradients(y.size());
 
-  for(size_t i = 0; i < y.size(); ++i) {
+  for (size_t i = 0; i < y.size(); ++i) {
     std::vector<double> f_y_t = {};
-    if(is_var<T_ts>::value)
+    if (is_var<T_ts>::value)
       f_y_t = f(value_of(ts[i]), value_of(y[i]), msgs, value_of(args)...);
 
-    for(size_t j = 0; j < y[i].size(); ++j) {
+    for (size_t j = 0; j < y[i].size(); ++j) {
       var tmp = y[i][j];
 
-      if(is_var<T_t0>::value)
-	tmp += internal::ode_time_gradient_var(t0, -f_y0_t0[j]);
+      if (is_var<T_t0>::value)
+        tmp += internal::ode_time_gradient_var(t0, -f_y0_t0[j]);
 
-      if(is_var<T_ts>::value)
-	tmp += internal::ode_time_gradient_var(ts[i], f_y_t[j]);
+      if (is_var<T_ts>::value)
+        tmp += internal::ode_time_gradient_var(ts[i], f_y_t[j]);
 
       y_with_gradients[i].push_back(tmp);
     }
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 53f6cdd7f25..e6438b5389e 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -15,42 +15,32 @@ template <typename F, typename T_initial, typename T_t0, typename T_ts,
 std::vector<std::vector<
     typename stan::return_type<T_initial, T_t0, T_ts, T_Args...>::type>>
 ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
-	const std::vector<T_ts>& ts,
-	std::ostream* msgs,
-	const T_Args&... args) {
+        const std::vector<T_ts>& ts, std::ostream* msgs,
+        const T_Args&... args) {
   double relative_tolerance = 1e-6;
   double absolute_tolerance = 1e-6;
   long int max_num_steps = 1e6;
 
-  return ode_bdf_tol(f, y0, t0, ts,
-		     relative_tolerance, absolute_tolerance,
-		     max_num_steps,
-		     msgs,
-		     args...);
+  return ode_bdf_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
+                     max_num_steps, msgs, args...);
 }
 
-template <typename F, typename T_initial, typename T_t0, typename T_ts, typename... T_Args>
-std::vector<std::vector<typename stan::return_type<T_initial, T_t0, T_ts, T_Args...>::type>>
-ode_bdf_tol(const F& f, const std::vector<T_initial>& y0,
-	    const T_t0& t0,
-	    const std::vector<T_ts>& ts,
-	    double relative_tolerance,
-	    double absolute_tolerance,
-	    long int max_num_steps,
-	    std::ostream* msgs,
-	    const T_Args&... args) {
+template <typename F, typename T_initial, typename T_t0, typename T_ts,
+          typename... T_Args>
+std::vector<std::vector<
+    typename stan::return_type<T_initial, T_t0, T_ts, T_Args...>::type>>
+ode_bdf_tol(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
+            const std::vector<T_ts>& ts, double relative_tolerance,
+            double absolute_tolerance, long int max_num_steps,
+            std::ostream* msgs, const T_Args&... args) {
   std::vector<double> value_of_ts = value_of(ts);
-  
-  stan::math::cvodes_integrator<CV_BDF, F, T_initial, T_Args...>
-    integrator(f, y0,
-	       value_of(t0), value_of_ts,
-	       relative_tolerance, absolute_tolerance,
-	       max_num_steps,
-	       msgs,
-	       args...);
+
+  stan::math::cvodes_integrator<CV_BDF, F, T_initial, T_Args...> integrator(
+      f, y0, value_of(t0), value_of_ts, relative_tolerance, absolute_tolerance,
+      max_num_steps, msgs, args...);
 
   auto y = integrator.integrate();
-  
+
   return ode_add_time_gradients(f, y0, t0, ts, y, msgs, args...);
 }
 
diff --git a/stan/math/rev/functor/ode_rk45.hpp b/stan/math/rev/functor/ode_rk45.hpp
index 7809f406f66..8a3853d0f0a 100644
--- a/stan/math/rev/functor/ode_rk45.hpp
+++ b/stan/math/rev/functor/ode_rk45.hpp
@@ -9,38 +9,28 @@
 namespace stan {
 namespace math {
 
-template <typename F, typename T_initial, typename T_t0, typename T_ts, typename... T_Args>
-std::vector<std::vector<var>>
-ode_rk45(const F& f, const std::vector<T_initial>& y0,
-	 const T_t0& t0,
-	 const std::vector<T_ts>& ts,
-	 std::ostream* msgs,
-	 const T_Args&... args) {
+template <typename F, typename T_initial, typename T_t0, typename T_ts,
+          typename... T_Args>
+std::vector<std::vector<var>> ode_rk45(
+    const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
+    const std::vector<T_ts>& ts, std::ostream* msgs, const T_Args&... args) {
   double relative_tolerance = 1e-6;
   double absolute_tolerance = 1e-6;
   long int max_num_steps = 1e6;
 
-  return ode_rk45_tol(f, y0, t0, ts,
-		      relative_tolerance, absolute_tolerance,
-		      max_num_steps,
-		      msgs,
-		      args...);
+  return ode_rk45_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
+                      max_num_steps, msgs, args...);
 }
-  
-template <typename F, typename T_initial, typename T_t0, typename T_ts, typename... T_Args>
-std::vector<std::vector<var>>
-ode_rk45_tol(const F& f, const std::vector<T_initial>& y0,
-	     const T_t0& t0,
-	     const std::vector<T_ts>& ts,
-	     double relative_tolerance,
-	     double absolute_tolerance,
-	     long int max_num_steps,
-	     std::ostream* msgs,
-	     const T_Args&... args) {
 
-  auto y = ode_rk45_tol(f, y0, value_of(t0), value_of(ts),
-			relative_tolerance, absolute_tolerance,
-			max_num_steps, msgs, args...);
+template <typename F, typename T_initial, typename T_t0, typename T_ts,
+          typename... T_Args>
+std::vector<std::vector<var>> ode_rk45_tol(
+    const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
+    const std::vector<T_ts>& ts, double relative_tolerance,
+    double absolute_tolerance, long int max_num_steps, std::ostream* msgs,
+    const T_Args&... args) {
+  auto y = ode_rk45_tol(f, y0, value_of(t0), value_of(ts), relative_tolerance,
+                        absolute_tolerance, max_num_steps, msgs, args...);
 
   return ode_add_time_gradients(f, y0, t0, ts, y, msgs, args...);
 }
diff --git a/test/unit/math/prim/functor/forced_harmonic_oscillator.hpp b/test/unit/math/prim/functor/forced_harmonic_oscillator.hpp
index f2c250d2c35..8f119750b9e 100644
--- a/test/unit/math/prim/functor/forced_harmonic_oscillator.hpp
+++ b/test/unit/math/prim/functor/forced_harmonic_oscillator.hpp
@@ -13,8 +13,7 @@ struct forced_harm_osc_ode_fun {
   // parameters
   // double data
   // integer data
-  operator()(const T0& t_in, const std::vector<T1>& y_in,
-	     std::ostream* msgs,
+  operator()(const T0& t_in, const std::vector<T1>& y_in, std::ostream* msgs,
              const std::vector<T2>& theta, const std::vector<double>& x,
              const std::vector<int>& x_int) const {
     if (y_in.size() != 2)
diff --git a/test/unit/math/prim/functor/harmonic_oscillator.hpp b/test/unit/math/prim/functor/harmonic_oscillator.hpp
index 86c221498d1..a49d17686b1 100644
--- a/test/unit/math/prim/functor/harmonic_oscillator.hpp
+++ b/test/unit/math/prim/functor/harmonic_oscillator.hpp
@@ -13,8 +13,7 @@ struct harm_osc_ode_fun {
   // parameters
   // double data
   // integer data
-  operator()(const T0& t_in, const std::vector<T1>& y_in,
-	     std::ostream* msgs,
+  operator()(const T0& t_in, const std::vector<T1>& y_in, std::ostream* msgs,
              const std::vector<T2>& theta, const std::vector<double>& x,
              const std::vector<int>& x_int) const {
     if (y_in.size() != 2)
@@ -37,8 +36,7 @@ struct harm_osc_ode_data_fun {
   // parameters
   // double data
   // integer data
-  operator()(const T0& t_in, const std::vector<T1>& y_in,
-	     std::ostream* msgs,
+  operator()(const T0& t_in, const std::vector<T1>& y_in, std::ostream* msgs,
              const std::vector<T2>& theta, const std::vector<double>& x,
              const std::vector<int>& x_int) const {
     if (y_in.size() != 2)
@@ -62,8 +60,7 @@ struct harm_osc_ode_wrong_size_1_fun {
   // parameters
   // double data
   // integer data
-  operator()(const T0& t_in, const std::vector<T1>& y_in,
-	     std::ostream* msgs,
+  operator()(const T0& t_in, const std::vector<T1>& y_in, std::ostream* msgs,
              const std::vector<T2>& theta, const std::vector<double>& x,
              const std::vector<int>& x_int) const {
     if (y_in.size() != 2)
@@ -87,8 +84,7 @@ struct harm_osc_ode_wrong_size_2_fun {
   // parameters
   // double data
   // integer data
-  operator()(const T0& t_in, const std::vector<T1>& y_in,
-	     std::ostream* msgs,
+  operator()(const T0& t_in, const std::vector<T1>& y_in, std::ostream* msgs,
              const std::vector<T2>& theta, const std::vector<double>& x,
              const std::vector<int>& x_int) const {
     if (y_in.size() != 2)
diff --git a/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp b/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
index f229724ba60..1368701a1c9 100644
--- a/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
+++ b/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
@@ -14,9 +14,8 @@ std::ostream* msgs = nullptr;
 template <typename F, typename... Args>
 void sho_death_test(F harm_osc, std::vector<double>& y0, double t0,
                     std::vector<double>& ts, Args&... args) {
-  EXPECT_DEATH(
-      stan::math::integrate_ode_rk45(harm_osc, y0, t0, ts, args...),
-      "");
+  EXPECT_DEATH(stan::math::integrate_ode_rk45(harm_osc, y0, t0, ts, args...),
+               "");
 }
 
 template <typename F, typename... Args>
@@ -104,44 +103,52 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions) {
   ASSERT_NO_THROW((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int)));
 
   std::vector<double> y0_bad;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
-                   std::invalid_argument, "initial state has size 0");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
+      std::invalid_argument, "initial state has size 0");
 
   double t0_bad = 2.0;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
-                   std::domain_error,
-                   "initial time is 2, but must be less than 0.1");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
+      std::domain_error, "initial time is 2, but must be less than 0.1");
 
   std::vector<double> ts_bad;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-                   std::invalid_argument, "times has size 0");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+      std::invalid_argument, "times has size 0");
 
   ts_bad.push_back(3);
   ts_bad.push_back(1);
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-                   std::domain_error, "times is not a valid ordered vector");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+      std::domain_error, "times is not a valid ordered vector");
 
   std::vector<double> theta_bad;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
-                   std::out_of_range, "vector");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
+      std::out_of_range, "vector");
 
   std::vector<double> x_bad;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
-                   std::out_of_range, "vector");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+      std::out_of_range, "vector");
 
   std::vector<int> x_int_bad;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int_bad)),
-                   std::out_of_range, "vector");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int_bad)),
+      std::out_of_range, "vector");
 
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int, 0, -1, 1e-6, 10)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int, 0,
+                                       -1, 1e-6, 10)),
                    std::invalid_argument, "relative_tolerance");
 
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int, 0, 1e-6, -1, 10)),
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int, 0,
+                                       1e-6, -1, 10)),
                    std::invalid_argument, "absolute_tolerance");
 
-  EXPECT_THROW_MSG(
-      (integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int, 0, 1e-6, 1e-6, -1)),
-      std::invalid_argument, "max_num_steps");
+  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int, 0,
+                                       1e-6, 1e-6, -1)),
+                   std::invalid_argument, "max_num_steps");
 }
 
 TEST(StanMathOde_integrate_ode_rk45, error_conditions_nan) {
@@ -172,38 +179,48 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions_nan) {
 
   std::vector<double> y0_bad = y0;
   y0_bad[0] = nan;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
-                   std::domain_error, "initial state");
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
-                   std::domain_error, expected_is_nan.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
+      std::domain_error, "initial state");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
+      std::domain_error, expected_is_nan.str());
 
   double t0_bad = nan;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
-                   std::domain_error, "initial time");
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
-                   std::domain_error, expected_is_nan.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
+      std::domain_error, "initial time");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
+      std::domain_error, expected_is_nan.str());
 
   std::vector<double> ts_bad = ts;
   ts_bad[0] = nan;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-                   std::domain_error, "times");
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-                   std::domain_error, expected_is_nan.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+      std::domain_error, "times");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+      std::domain_error, expected_is_nan.str());
 
   std::vector<double> theta_bad = theta;
   theta_bad[0] = nan;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
-                   std::domain_error, "parameters and data");
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
-                   std::domain_error, expected_is_nan.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
+      std::domain_error, "parameters and data");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
+      std::domain_error, expected_is_nan.str());
 
   if (x.size() > 0) {
     std::vector<double> x_bad = x;
     x_bad[0] = nan;
-    EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
-                     std::domain_error, "parameters and data");
-    EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
-                     std::domain_error, expected_is_nan.str());
+    EXPECT_THROW_MSG(
+        (integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+        std::domain_error, "parameters and data");
+    EXPECT_THROW_MSG(
+        (integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+        std::domain_error, expected_is_nan.str());
   }
 }
 
@@ -236,63 +253,83 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions_inf) {
   double inf = std::numeric_limits<double>::infinity();
   std::vector<double> y0_bad = y0;
   y0_bad[0] = inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
-                   std::domain_error, "initial state");
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
-                   std::domain_error, expected_is_inf.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
+      std::domain_error, "initial state");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
+      std::domain_error, expected_is_inf.str());
 
   y0_bad[0] = -inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
-                   std::domain_error, "initial state");
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
-                   std::domain_error, expected_is_neg_inf.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
+      std::domain_error, "initial state");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
+      std::domain_error, expected_is_neg_inf.str());
 
   double t0_bad = inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
-                   std::domain_error, "initial time");
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
-                   std::domain_error, expected_is_inf.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
+      std::domain_error, "initial time");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
+      std::domain_error, expected_is_inf.str());
   t0_bad = -inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
-                   std::domain_error, "initial time");
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
-                   std::domain_error, expected_is_neg_inf.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
+      std::domain_error, "initial time");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0_bad, ts, theta, x, x_int)),
+      std::domain_error, expected_is_neg_inf.str());
 
   std::vector<double> ts_bad = ts;
   ts_bad.push_back(inf);
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-                   std::domain_error, "times");
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-                   std::domain_error, expected_is_inf.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+      std::domain_error, "times");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+      std::domain_error, expected_is_inf.str());
   ts_bad[0] = -inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-                   std::domain_error, "times");
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-                   std::domain_error, expected_is_neg_inf.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+      std::domain_error, "times");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
+      std::domain_error, expected_is_neg_inf.str());
 
   std::vector<double> theta_bad = theta;
   theta_bad[0] = inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
-                   std::domain_error, "parameters and data");
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
-                   std::domain_error, expected_is_inf.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
+      std::domain_error, "parameters and data");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
+      std::domain_error, expected_is_inf.str());
   theta_bad[0] = -inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
-                   std::domain_error, "parameters and data");
-  EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
-                   std::domain_error, expected_is_neg_inf.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
+      std::domain_error, "parameters and data");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0, t0, ts, theta_bad, x, x_int)),
+      std::domain_error, expected_is_neg_inf.str());
 
   if (x.size() > 0) {
     std::vector<double> x_bad = x;
     x_bad[0] = inf;
-    EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
-                     std::domain_error, "parameters and data");
-    EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
-                     std::domain_error, expected_is_inf.str());
+    EXPECT_THROW_MSG(
+        (integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+        std::domain_error, "parameters and data");
+    EXPECT_THROW_MSG(
+        (integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+        std::domain_error, expected_is_inf.str());
     x_bad[0] = -inf;
-    EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
-                     std::domain_error, "parameters and data");
-    EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
-                     std::domain_error, expected_is_neg_inf.str());
+    EXPECT_THROW_MSG(
+        (integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+        std::domain_error, "parameters and data");
+    EXPECT_THROW_MSG(
+        (integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x_bad, x_int)),
+        std::domain_error, expected_is_neg_inf.str());
   }
 }
diff --git a/test/unit/math/prim/functor/lorenz.hpp b/test/unit/math/prim/functor/lorenz.hpp
index e905e78837c..5914f39de72 100644
--- a/test/unit/math/prim/functor/lorenz.hpp
+++ b/test/unit/math/prim/functor/lorenz.hpp
@@ -29,8 +29,7 @@ struct lorenz_ode_fun {
   // parameters
   // double data
   // integer data
-  operator()(const T0& t_in, const std::vector<T1>& y_in,
-	     std::ostream* msgs,
+  operator()(const T0& t_in, const std::vector<T1>& y_in, std::ostream* msgs,
              const std::vector<T2>& theta, const std::vector<double>& x,
              const std::vector<int>& x_int) const {
     return lorenz_ode(t_in, y_in, theta, x, x_int);
diff --git a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
index 897acd13159..11e6c356c11 100644
--- a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
@@ -288,10 +288,10 @@ TEST(StanAgradRevOde_integrate_ode_bdf, t0_as_param_AD) {
       std::vector<double> res_d = value_of(res[i]);
       for (auto j = 0; j < ns; ++j) {
         res[i][0].grad();
-	EXPECT_FLOAT_EQ(t0v.adj(), 0.0);
+        EXPECT_FLOAT_EQ(t0v.adj(), 0.0);
         stan::math::set_zero_all_adjoints();
         res[i][1].grad();
-	EXPECT_FLOAT_EQ(t0v.adj(), 1.0);
+        EXPECT_FLOAT_EQ(t0v.adj(), 1.0);
         stan::math::set_zero_all_adjoints();
       }
     }
diff --git a/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
index b8f9bae8fdf..0be95f1c88c 100644
--- a/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
@@ -16,10 +16,9 @@ void sho_value_test(F harm_osc, std::vector<double>& y0, double t0,
   using stan::math::promote_scalar;
   using stan::math::var;
 
-  std::vector<std::vector<var>> ode_res_vd
-      = stan::math::integrate_ode_rk45(
-          harm_osc, promote_scalar<T_y0>(y0), t0, ts,
-          promote_scalar<T_theta>(theta), x, x_int, 0);
+  std::vector<std::vector<var>> ode_res_vd = stan::math::integrate_ode_rk45(
+      harm_osc, promote_scalar<T_y0>(y0), t0, ts,
+      promote_scalar<T_theta>(theta), x, x_int, 0);
   EXPECT_NEAR(0.995029, ode_res_vd[0][0].val(), 1e-5);
   EXPECT_NEAR(-0.0990884, ode_res_vd[0][1].val(), 1e-5);
 
@@ -140,8 +139,7 @@ TEST(StanAgradRevOde_integrate_ode_rk45, time_steps_as_param) {
   std::vector<std::vector<stan::math::var>> res;
 
   std::vector<std::vector<double>> res_d
-      = integrate_ode_rk45(ode, y0, t0, value_of(ts), theta,
-                                             x, x_int);
+      = integrate_ode_rk45(ode, y0, t0, value_of(ts), theta, x, x_int);
 
   // here we only test first & last steps, and rely on the
   // fact that results in-between affect the initial
@@ -158,19 +156,15 @@ TEST(StanAgradRevOde_integrate_ode_rk45, time_steps_as_param) {
   test_val();
   res = integrate_ode_rk45(ode, y0, t0, ts, thetav, x, x_int);
   test_val();
-  res = integrate_ode_rk45(ode, y0v, t0, ts, thetav, x,
-                                             x_int);
+  res = integrate_ode_rk45(ode, y0v, t0, ts, thetav, x, x_int);
   test_val();
   res = integrate_ode_rk45(ode, y0, t0v, ts, theta, x, x_int);
   test_val();
-  res = integrate_ode_rk45(ode, y0v, t0v, ts, theta, x,
-                                             x_int);
+  res = integrate_ode_rk45(ode, y0v, t0v, ts, theta, x, x_int);
   test_val();
-  res = integrate_ode_rk45(ode, y0, t0v, ts, thetav, x,
-                                             x_int);
+  res = integrate_ode_rk45(ode, y0, t0v, ts, thetav, x, x_int);
   test_val();
-  res = integrate_ode_rk45(ode, y0v, t0v, ts, thetav, x,
-                                             x_int);
+  res = integrate_ode_rk45(ode, y0v, t0v, ts, thetav, x, x_int);
   test_val();
 }
 
@@ -225,8 +219,7 @@ TEST(StanAgradRevOde_integrate_ode_rk45, time_steps_as_param_AD) {
   test_ad();
   res = integrate_ode_rk45(ode, y0, t0, ts, thetav, x, x_int);
   test_ad();
-  res = integrate_ode_rk45(ode, y0v, t0, ts, thetav, x,
-                                             x_int);
+  res = integrate_ode_rk45(ode, y0v, t0, ts, thetav, x, x_int);
   test_ad();
 }
 
@@ -268,13 +261,10 @@ TEST(StanAgradRevOde_integrate_ode_rk45, t0_as_param_AD) {
   };
   res = integrate_ode_rk45(ode, y0, t0v, ts, theta, x, x_int);
   test_ad();
-  res = integrate_ode_rk45(ode, y0v, t0v, ts, theta, x,
-                                             x_int);
+  res = integrate_ode_rk45(ode, y0v, t0v, ts, theta, x, x_int);
   test_ad();
-  res = integrate_ode_rk45(ode, y0, t0v, ts, thetav, x,
-                                             x_int);
+  res = integrate_ode_rk45(ode, y0, t0v, ts, thetav, x, x_int);
   test_ad();
-  res = integrate_ode_rk45(ode, y0v, t0v, ts, thetav, x,
-                                             x_int);
+  res = integrate_ode_rk45(ode, y0v, t0v, ts, thetav, x, x_int);
   test_ad();
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index 8bfd73e0d28..0b7cda95723 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -29,22 +29,21 @@ auto sum_(Vec&& arg) {
 
 struct CosArg1 {
   template <typename T0, typename T1, typename... T_Args>
-  inline std::vector<stan::return_type_t<T1, T_Args...>>
-  operator()(const T0& t, const std::vector<T1>& y,
-	     std::ostream* msgs, const T_Args&... a) const {
-
-    std::vector<typename stan::return_type<T0, T_Args...>::type> vec = { sum_(a)... };
-    return { stan::math::cos(sum_(vec) * t) };
+  inline std::vector<stan::return_type_t<T1, T_Args...>> operator()(
+      const T0& t, const std::vector<T1>& y, std::ostream* msgs,
+      const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    return {stan::math::cos(sum_(vec) * t)};
   }
 };
 
 struct Cos2Arg {
   template <typename T0, typename T1, typename T2, typename T3>
-  inline std::vector<typename stan::return_type<T1, T2, T3>::type>
-  operator()(const T0& t, const std::vector<T1>& y,
-	      std::ostream* msgs, const T2& a, const T3& b) const {
-    
-    return { stan::math::cos((sum_(a) + sum_(b)) * t) };
+  inline std::vector<typename stan::return_type<T1, T2, T3>::type> operator()(
+      const T0& t, const std::vector<T1>& y, std::ostream* msgs, const T2& a,
+      const T3& b) const {
+    return {stan::math::cos((sum_(a) + sum_(b)) * t)};
   }
 };
 
@@ -56,8 +55,9 @@ TEST(StanMathOde_ode_bdf_tol, t0) {
   std::vector<double> ts = {0.45, 1.1};
 
   double a = 1.5;
-  
-  std::vector<std::vector<var>> output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
+
+  std::vector<std::vector<var>> output = stan::math::ode_bdf_tol(
+      CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
 
   output[0][0].grad();
 
@@ -80,8 +80,9 @@ TEST(StanMathOde_ode_bdf_tol, ts) {
   std::vector<var> ts = {0.45, 1.1};
 
   double a = 1.5;
-  
-  std::vector<std::vector<var>> output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
+
+  std::vector<std::vector<var>> output = stan::math::ode_bdf_tol(
+      CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
 
   output[0][0].grad();
 
@@ -104,8 +105,9 @@ TEST(StanMathOde_ode_bdf_tol, scalar_arg) {
   std::vector<double> ts = {1.1};
 
   var a = 1.5;
-  
-  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -120,9 +122,10 @@ TEST(StanMathOde_ode_bdf_tol, std_vector_arg) {
   double t0 = 0.0;
   std::vector<double> ts = {1.1};
 
-  std::vector<var> a = { 1.5 };
-  
-  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+  std::vector<var> a = {1.5};
+
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -139,8 +142,9 @@ TEST(StanMathOde_ode_bdf_tol, vector_arg) {
 
   Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
   a << 1.5;
-  
-  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -157,8 +161,9 @@ TEST(StanMathOde_ode_bdf_tol, row_vector_arg) {
 
   Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
   a << 1.5;
-  
-  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -175,8 +180,9 @@ TEST(StanMathOde_ode_bdf_tol, matrix_arg) {
 
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
   a << 1.5;
-  
-  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -192,10 +198,10 @@ TEST(StanMathOde_ode_bdf_tol, scalar_std_vector_args) {
   std::vector<double> ts = {1.1};
 
   var a0 = 0.0;
-  std::vector<var> a1 = { 1.5 };
-  
-  var output = stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr,
-				   a0, a1)[0][0];
+  std::vector<var> a1 = {1.5};
+
+  var output = stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a0, a1)[0][0];
 
   output.grad();
 
diff --git a/test/unit/math/rev/functor/ode_rk45_prim_test.cpp b/test/unit/math/rev/functor/ode_rk45_prim_test.cpp
index 2483066fcb5..be038285806 100644
--- a/test/unit/math/rev/functor/ode_rk45_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_prim_test.cpp
@@ -29,35 +29,35 @@ auto sum_(Vec&& arg) {
 
 struct CosArg1 {
   template <typename T0, typename T1, typename... T_Args>
-  inline std::vector<stan::return_type_t<T1, T_Args...>>
-  operator()(const T0& t, const std::vector<T1>& y,
-	     std::ostream* msgs, const T_Args&... a) const {
-
-    std::vector<typename stan::return_type<T0, T_Args...>::type> vec = { sum_(a)... };
-    return { stan::math::cos(sum_(vec) * t) };
+  inline std::vector<stan::return_type_t<T1, T_Args...>> operator()(
+      const T0& t, const std::vector<T1>& y, std::ostream* msgs,
+      const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    return {stan::math::cos(sum_(vec) * t)};
   }
 };
 
 struct Cos2Arg {
   template <typename T0, typename T1, typename T2, typename T3>
-  inline std::vector<typename stan::return_type<T1, T2, T3>::type>
-  operator()(const T0& t, const std::vector<T1>& y,
-	      std::ostream* msgs, const T2& a, const T3& b) const {
-    
-    return { stan::math::cos((sum_(a) + sum_(b)) * t) };
+  inline std::vector<typename stan::return_type<T1, T2, T3>::type> operator()(
+      const T0& t, const std::vector<T1>& y, std::ostream* msgs, const T2& a,
+      const T3& b) const {
+    return {stan::math::cos((sum_(a) + sum_(b)) * t)};
   }
 };
 
 TEST(StanMathOde_ode_rk45_tol, t0) {
   using stan::math::var;
-  
-  std::vector<double> y0 = { 0.0 };
+
+  std::vector<double> y0 = {0.0};
   var t0 = 0.0;
-  std::vector<double> ts = { 0.45, 1.1 };
+  std::vector<double> ts = {0.45, 1.1};
 
   double a = 1.5;
-  
-  std::vector<std::vector<var>> output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
+
+  std::vector<std::vector<var>> output = stan::math::ode_rk45_tol(
+      CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
 
   output[0][0].grad();
 
@@ -74,14 +74,15 @@ TEST(StanMathOde_ode_rk45_tol, t0) {
 
 TEST(StanMathOde_ode_rk45_tol, ts) {
   using stan::math::var;
-  
-  std::vector<double> y0 = { 0.0 };
+
+  std::vector<double> y0 = {0.0};
   double t0 = 0.0;
-  std::vector<var> ts = { 0.45, 1.1 };
+  std::vector<var> ts = {0.45, 1.1};
 
   double a = 1.5;
-  
-  std::vector<std::vector<var>> output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
+
+  std::vector<std::vector<var>> output = stan::math::ode_rk45_tol(
+      CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
 
   output[0][0].grad();
 
@@ -91,21 +92,22 @@ TEST(StanMathOde_ode_rk45_tol, ts) {
   stan::math::set_zero_all_adjoints();
 
   output[1][0].grad();
-  
+
   EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
   EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
 }
 
 TEST(StanMathOde_ode_rk45_tol, scalar_arg) {
   using stan::math::var;
-  
-  std::vector<double> y0 = { 0.0 };
+
+  std::vector<double> y0 = {0.0};
   double t0 = 0.0;
-  std::vector<double> ts = { 1.1 };
+  std::vector<double> ts = {1.1};
 
   var a = 1.5;
-  
-  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -115,14 +117,15 @@ TEST(StanMathOde_ode_rk45_tol, scalar_arg) {
 
 TEST(StanMathOde_ode_rk45_tol, std_vector_arg) {
   using stan::math::var;
-  
-  std::vector<double> y0 = { 0.0 };
+
+  std::vector<double> y0 = {0.0};
   double t0 = 0.0;
-  std::vector<double> ts = { 1.1 };
+  std::vector<double> ts = {1.1};
 
-  std::vector<var> a = { 1.5 };
-  
-  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+  std::vector<var> a = {1.5};
+
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -132,15 +135,16 @@ TEST(StanMathOde_ode_rk45_tol, std_vector_arg) {
 
 TEST(StanMathOde_ode_rk45_tol, vector_arg) {
   using stan::math::var;
-  
-  std::vector<double> y0 = { 0.0 };
+
+  std::vector<double> y0 = {0.0};
   double t0 = 0.0;
-  std::vector<double> ts = { 1.1 };
+  std::vector<double> ts = {1.1};
 
   Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
   a << 1.5;
-  
-  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -150,15 +154,16 @@ TEST(StanMathOde_ode_rk45_tol, vector_arg) {
 
 TEST(StanMathOde_ode_rk45_tol, row_vector_arg) {
   using stan::math::var;
-  
-  std::vector<double> y0 = { 0.0 };
+
+  std::vector<double> y0 = {0.0};
   double t0 = 0.0;
-  std::vector<double> ts = { 1.1 };
+  std::vector<double> ts = {1.1};
 
   Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
   a << 1.5;
-  
-  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -168,15 +173,16 @@ TEST(StanMathOde_ode_rk45_tol, row_vector_arg) {
 
 TEST(StanMathOde_ode_rk45_tol, matrix_arg) {
   using stan::math::var;
-  
-  std::vector<double> y0 = { 0.0 };
+
+  std::vector<double> y0 = {0.0};
   double t0 = 0.0;
-  std::vector<double> ts = { 1.1 };
+  std::vector<double> ts = {1.1};
 
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
   a << 1.5;
-  
-  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr, a)[0][0];
+
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -186,16 +192,16 @@ TEST(StanMathOde_ode_rk45_tol, matrix_arg) {
 
 TEST(StanMathOde_ode_rk45_tol, scalar_std_vector_args) {
   using stan::math::var;
-  
-  std::vector<double> y0 = { 0.0 };
+
+  std::vector<double> y0 = {0.0};
   double t0 = 0.0;
-  std::vector<double> ts = { 1.1 };
+  std::vector<double> ts = {1.1};
 
   var a0 = 0.0;
-  std::vector<var> a1 = { 1.5 };
-  
-  var output = stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6, nullptr,
-				   a0, a1)[0][0];
+  std::vector<var> a1 = {1.5};
+
+  var output = stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a0, a1)[0][0];
 
   output.grad();
 
diff --git a/test/unit/math/rev/functor/util.hpp b/test/unit/math/rev/functor/util.hpp
index 7461ee747d1..26a537ec7b3 100644
--- a/test/unit/math/rev/functor/util.hpp
+++ b/test/unit/math/rev/functor/util.hpp
@@ -29,12 +29,10 @@ std::vector<std::vector<double>> finite_diff_params(
   std::vector<std::vector<double>> ode_res_ub;
   std::vector<std::vector<double>> ode_res_lb;
 
-  ode_res_ub
-      = stan::math::integrate_ode_rk45(
-          f, y_in, t_in, ts, theta_ub, x, x_int, &msgs);
-  ode_res_lb
-      = stan::math::integrate_ode_rk45(
-          f, y_in, t_in, ts, theta_lb, x, x_int, &msgs);
+  ode_res_ub = stan::math::integrate_ode_rk45(f, y_in, t_in, ts, theta_ub, x,
+                                              x_int, &msgs);
+  ode_res_lb = stan::math::integrate_ode_rk45(f, y_in, t_in, ts, theta_lb, x,
+                                              x_int, &msgs);
 
   std::vector<std::vector<double>> results(ts.size());
 
@@ -67,12 +65,10 @@ std::vector<std::vector<double>> finite_diff_initial_position(
   std::vector<std::vector<double>> ode_res_ub;
   std::vector<std::vector<double>> ode_res_lb;
 
-  ode_res_ub
-      = stan::math::integrate_ode_rk45(
-          f, y_in_ub, t_in, ts, theta, x, x_int, &msgs);
-  ode_res_lb
-      = stan::math::integrate_ode_rk45(
-          f, y_in_lb, t_in, ts, theta, x, x_int, &msgs);
+  ode_res_ub = stan::math::integrate_ode_rk45(f, y_in_ub, t_in, ts, theta, x,
+                                              x_int, &msgs);
+  ode_res_lb = stan::math::integrate_ode_rk45(f, y_in_lb, t_in, ts, theta, x,
+                                              x_int, &msgs);
 
   std::vector<std::vector<double>> results(ts.size());
 
@@ -107,9 +103,8 @@ void test_ode_finite_diff_dv(const F& f, const double& t_in,
 
   std::vector<std::vector<stan::math::var>> ode_res;
 
-  ode_res
-      = stan::math::integrate_ode_rk45(
-          f, y_in, t_in, ts, theta_v, x, x_int, &msgs);
+  ode_res = stan::math::integrate_ode_rk45(f, y_in, t_in, ts, theta_v, x, x_int,
+                                           &msgs);
 
   for (size_t i = 0; i < ts.size(); i++) {
     for (size_t j = 0; j < y_in.size(); j++) {
@@ -152,9 +147,8 @@ void test_ode_finite_diff_vd(const F& f, const double& t_in,
 
   std::vector<std::vector<stan::math::var>> ode_res;
 
-  ode_res
-      = stan::math::integrate_ode_rk45(
-          f, y_in_v, t_in, ts, theta, x, x_int, &msgs);
+  ode_res = stan::math::integrate_ode_rk45(f, y_in_v, t_in, ts, theta, x, x_int,
+                                           &msgs);
 
   for (size_t i = 0; i < ts.size(); i++) {
     for (size_t j = 0; j < y_in.size(); j++) {
@@ -210,9 +204,8 @@ void test_ode_finite_diff_vv(const F& f, const double& t_in,
 
   std::vector<std::vector<stan::math::var>> ode_res;
 
-  ode_res
-      = stan::math::integrate_ode_rk45(
-          f, y_in_v, t_in, ts, theta_v, x, x_int, &msgs);
+  ode_res = stan::math::integrate_ode_rk45(f, y_in_v, t_in, ts, theta_v, x,
+                                           x_int, &msgs);
 
   for (size_t i = 0; i < ts.size(); i++) {
     for (size_t j = 0; j < y_in.size(); j++) {
@@ -247,15 +240,14 @@ void test_ode_error_conditions(F& f, const double& t0,
   using stan::math::integrate_ode_rk45;
   std::stringstream msgs;
 
-  ASSERT_NO_THROW((
-      integrate_ode_rk45(f, y0, t0, ts, theta, x, x_int, 0)));
+  ASSERT_NO_THROW((integrate_ode_rk45(f, y0, t0, ts, theta, x, x_int, 0)));
   ASSERT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T1> y0_bad;
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
-                   std::invalid_argument, "initial state has size 0");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
+      std::invalid_argument, "initial state has size 0");
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
@@ -263,48 +255,48 @@ void test_ode_error_conditions(F& f, const double& t0,
   std::stringstream expected_msg;
   expected_msg << "initial time is " << t0_bad << ", but must be less than "
                << ts[0];
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
-                   std::domain_error, expected_msg.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
+      std::domain_error, expected_msg.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<double> ts_bad;
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-                   std::invalid_argument, "times has size 0");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
+      std::invalid_argument, "times has size 0");
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   ts_bad.push_back(3);
   ts_bad.push_back(1);
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-                   std::domain_error, "times is not a valid ordered vector");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
+      std::domain_error, "times is not a valid ordered vector");
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T2> theta_bad;
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
-                   std::out_of_range, "vector");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+      std::out_of_range, "vector");
   EXPECT_EQ("", msgs.str());
 
   if (x.size() > 0) {
     msgs.clear();
     std::vector<double> x_bad;
-    EXPECT_THROW_MSG((integrate_ode_rk45(
-                         f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
-                     std::out_of_range, "vector");
+    EXPECT_THROW_MSG(
+        (integrate_ode_rk45(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+        std::out_of_range, "vector");
     EXPECT_EQ("", msgs.str());
   }
 
   if (x_int.size() > 0) {
     msgs.clear();
     std::vector<int> x_int_bad;
-    EXPECT_THROW_MSG((integrate_ode_rk45(
-                         f, y0, t0, ts, theta, x, x_int_bad, &msgs)),
-                     std::out_of_range, "vector");
+    EXPECT_THROW_MSG(
+        (integrate_ode_rk45(f, y0, t0, ts, theta, x, x_int_bad, &msgs)),
+        std::out_of_range, "vector");
     EXPECT_EQ("", msgs.str());
   }
 }
@@ -322,63 +314,62 @@ void test_ode_error_conditions_nan(F& f, const double& t0,
   std::stringstream expected_is_nan;
   expected_is_nan << "is " << nan;
 
-  ASSERT_NO_THROW((
-      integrate_ode_rk45(f, y0, t0, ts, theta, x, x_int, 0)));
+  ASSERT_NO_THROW((integrate_ode_rk45(f, y0, t0, ts, theta, x, x_int, 0)));
   ASSERT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T1> y0_bad = y0;
   y0_bad[0] = nan;
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
-                   std::domain_error, "initial state");
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
-                   std::domain_error, expected_is_nan.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
+      std::domain_error, "initial state");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
+      std::domain_error, expected_is_nan.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   double t0_bad = nan;
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
-                   std::domain_error, "initial time");
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
-                   std::domain_error, expected_is_nan.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
+      std::domain_error, "initial time");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
+      std::domain_error, expected_is_nan.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<double> ts_bad = ts;
   ts_bad[0] = nan;
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-                   std::domain_error, "times");
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-                   std::domain_error, expected_is_nan.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
+      std::domain_error, "times");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
+      std::domain_error, expected_is_nan.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T2> theta_bad = theta;
   theta_bad[0] = nan;
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
-                   std::domain_error, "ode parameters and data");
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
-                   std::domain_error, expected_is_nan.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+      std::domain_error, "ode parameters and data");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+      std::domain_error, expected_is_nan.str());
   EXPECT_EQ("", msgs.str());
 
   if (x.size() > 0) {
     msgs.clear();
     std::vector<double> x_bad = x;
     x_bad[0] = nan;
-    EXPECT_THROW_MSG((integrate_ode_rk45(
-                         f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
-                     std::domain_error, "ode parameters and data");
-    EXPECT_THROW_MSG((integrate_ode_rk45(
-                         f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
-                     std::domain_error, expected_is_nan.str());
+    EXPECT_THROW_MSG(
+        (integrate_ode_rk45(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+        std::domain_error, "ode parameters and data");
+    EXPECT_THROW_MSG(
+        (integrate_ode_rk45(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+        std::domain_error, expected_is_nan.str());
     EXPECT_EQ("", msgs.str());
   }
 }
@@ -398,98 +389,97 @@ void test_ode_error_conditions_inf(F& f, const double& t0,
   std::stringstream expected_is_neg_inf;
   expected_is_neg_inf << "is " << -inf;
 
-  ASSERT_NO_THROW((
-      integrate_ode_rk45(f, y0, t0, ts, theta, x, x_int, 0)));
+  ASSERT_NO_THROW((integrate_ode_rk45(f, y0, t0, ts, theta, x, x_int, 0)));
   ASSERT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T1> y0_bad = y0;
   y0_bad[0] = inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
-                   std::domain_error, "initial state");
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
-                   std::domain_error, expected_is_inf.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
+      std::domain_error, "initial state");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
+      std::domain_error, expected_is_inf.str());
   y0_bad[0] = -inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
-                   std::domain_error, "initial state");
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
-                   std::domain_error, expected_is_neg_inf.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
+      std::domain_error, "initial state");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0_bad, t0, ts, theta, x, x_int, &msgs)),
+      std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   double t0_bad = inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
-                   std::domain_error, "initial time");
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
-                   std::domain_error, expected_is_inf.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
+      std::domain_error, "initial time");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
+      std::domain_error, expected_is_inf.str());
   t0_bad = -inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
-                   std::domain_error, "initial time");
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
-                   std::domain_error, expected_is_neg_inf.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
+      std::domain_error, "initial time");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0_bad, ts, theta, x, x_int, &msgs)),
+      std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<double> ts_bad = ts;
   ts_bad[0] = inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-                   std::domain_error, "times");
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-                   std::domain_error, expected_is_inf.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
+      std::domain_error, "times");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
+      std::domain_error, expected_is_inf.str());
   ts_bad[0] = -inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-                   std::domain_error, "times");
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-                   std::domain_error, expected_is_neg_inf.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
+      std::domain_error, "times");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
+      std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
   std::vector<T2> theta_bad = theta;
   theta_bad[0] = inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
-                   std::domain_error, "ode parameters and data");
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
-                   std::domain_error, expected_is_inf.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+      std::domain_error, "ode parameters and data");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+      std::domain_error, expected_is_inf.str());
   theta_bad[0] = -inf;
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
-                   std::domain_error, "ode parameters and data");
-  EXPECT_THROW_MSG((integrate_ode_rk45(
-                       f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
-                   std::domain_error, expected_is_neg_inf.str());
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+      std::domain_error, "ode parameters and data");
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(f, y0, t0, ts, theta_bad, x, x_int, &msgs)),
+      std::domain_error, expected_is_neg_inf.str());
   EXPECT_EQ("", msgs.str());
 
   if (x.size() > 0) {
     msgs.clear();
     std::vector<double> x_bad = x;
     x_bad[0] = inf;
-    EXPECT_THROW_MSG((integrate_ode_rk45(
-                         f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
-                     std::domain_error, "ode parameters and data");
-    EXPECT_THROW_MSG((integrate_ode_rk45(
-                         f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
-                     std::domain_error, expected_is_inf.str());
+    EXPECT_THROW_MSG(
+        (integrate_ode_rk45(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+        std::domain_error, "ode parameters and data");
+    EXPECT_THROW_MSG(
+        (integrate_ode_rk45(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+        std::domain_error, expected_is_inf.str());
     x_bad[0] = -inf;
-    EXPECT_THROW_MSG((integrate_ode_rk45(
-                         f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
-                     std::domain_error, "ode parameters and data");
-    EXPECT_THROW_MSG((integrate_ode_rk45(
-                         f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
-                     std::domain_error, expected_is_neg_inf.str());
+    EXPECT_THROW_MSG(
+        (integrate_ode_rk45(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+        std::domain_error, "ode parameters and data");
+    EXPECT_THROW_MSG(
+        (integrate_ode_rk45(f, y0, t0, ts, theta, x_bad, x_int, &msgs)),
+        std::domain_error, expected_is_neg_inf.str());
     EXPECT_EQ("", msgs.str());
   }
 }

From 8642b0870fe34eac71ff81bbef831cc46b76dc3e Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 13 Apr 2020 10:35:15 -0400
Subject: [PATCH 104/189] Reverting accidental changes to reduce_sum on this
 branch (Issue #1833)

---
 stan/math/prim/functor.hpp                    |   1 +
 .../unit/math/mix/functor/reduce_sum_test.cpp | 291 ------------------
 .../unit/math/rev/functor/reduce_sum_test.cpp |   2 +-
 3 files changed, 2 insertions(+), 292 deletions(-)
 delete mode 100644 test/unit/math/mix/functor/reduce_sum_test.cpp

diff --git a/stan/math/prim/functor.hpp b/stan/math/prim/functor.hpp
index c53ff26eeb6..7a326490b8e 100644
--- a/stan/math/prim/functor.hpp
+++ b/stan/math/prim/functor.hpp
@@ -21,4 +21,5 @@
 #include <stan/math/prim/functor/mpi_distributed_apply.hpp>
 #include <stan/math/prim/functor/reduce_sum.hpp>
 #include <stan/math/prim/functor/reduce_sum_static.hpp>
+
 #endif
diff --git a/test/unit/math/mix/functor/reduce_sum_test.cpp b/test/unit/math/mix/functor/reduce_sum_test.cpp
deleted file mode 100644
index 689f0544cb0..00000000000
--- a/test/unit/math/mix/functor/reduce_sum_test.cpp
+++ /dev/null
@@ -1,291 +0,0 @@
-#include <stan/math/prim/meta.hpp>
-#include <test/unit/math/test_ad.hpp>
-
-#include <limits>
-#include <vector>
-
-std::ostream* msgs = nullptr;
-
-template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
-T sum_(T arg) {
-  return arg;
-}
-
-template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
-auto sum_(EigMat&& arg) {
-  return stan::math::sum(arg);
-}
-
-template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
-auto sum_(Vec&& arg) {
-  stan::scalar_type_t<Vec> sum = 0;
-  for (size_t i = 0; i < arg.size(); ++i) {
-    sum += sum_(arg[i]);
-  }
-  return sum;
-}
-
-struct sum_lpdf {
-  template <typename T, typename... Args>
-  inline auto operator()(std::size_t start, std::size_t end, T&& sub_slice,
-                         std::ostream* msgs, Args&&... args) const {
-    using return_type = stan::return_type_t<T, Args...>;
-
-    return sum_(sub_slice)
-           + sub_slice.size()
-                 * stan::math::sum(std::vector<return_type>{
-                       return_type(sum_(std::forward<Args>(args)))...});
-  }
-};
-
-TEST(MathMix_reduce_sum, double_slice) {
-  auto f = [](auto&& data) {
-    return stan::math::reduce_sum<sum_lpdf>(data, 0, msgs);
-  };
-
-  std::vector<double> data(5, 10.0);
-
-  stan::test::expect_ad(f, data);
-}
-
-TEST(MathMix_reduce_sum, std_vector_double_slice) {
-  auto f = [](auto&& data) {
-    return stan::math::reduce_sum<sum_lpdf>(data, 0, msgs);
-  };
-
-  std::vector<std::vector<double>> data(3, std::vector<double>(2, 10.0));
-
-  stan::test::expect_ad(f, data);
-}
-
-TEST(MathMix_reduce_sum, vector_double_slice) {
-  auto f = [](auto&& data) {
-    return stan::math::reduce_sum<sum_lpdf>(data, 0, msgs);
-  };
-
-  std::vector<Eigen::VectorXd> data(3, Eigen::VectorXd::Ones(2));
-
-  stan::test::expect_ad(f, data);
-}
-
-TEST(MathMix_reduce_sum, row_vector_double_slice) {
-  auto f = [](auto&& data) {
-    return stan::math::reduce_sum<sum_lpdf>(data, 0, msgs);
-  };
-
-  std::vector<Eigen::RowVectorXd> data(3, Eigen::RowVectorXd::Ones(2));
-
-  stan::test::expect_ad(f, data);
-}
-
-TEST(MathMix_reduce_sum, matrix_double_slice) {
-  auto f = [](auto&& data) {
-    return stan::math::reduce_sum<sum_lpdf>(data, 0, msgs);
-  };
-
-  std::vector<Eigen::MatrixXd> data(3, Eigen::MatrixXd::Ones(2, 4));
-
-  stan::test::expect_ad(f, data);
-}
-
-struct start_end_lpdf {
-  template <typename T1, typename T2>
-  inline auto operator()(std::size_t start, std::size_t end, T1&&,
-                         std::ostream* msgs, T2&& data) const {
-    stan::return_type_t<T1, T2> sum = 0;
-    EXPECT_GE(start, 0);
-    EXPECT_LE(end, data.size() - 1);
-    for (size_t i = start; i <= end; i++) {
-      sum += data[i];
-    }
-    return sum;
-  }
-};
-
-TEST(StanMath_reduce_sum, start_end_slice) {
-  auto start_end = [](auto&& arg) {
-    return stan::math::reduce_sum<start_end_lpdf>(arg, 0, msgs, arg);
-  };
-
-  std::vector<double> data(5, 1.0);
-
-  stan::test::expect_ad(start_end, data);
-}
-
-auto fi = [](auto&&... args) {
-  return stan::math::reduce_sum<sum_lpdf>(std::vector<int>(2, 10.0), 0, msgs,
-                                          args...);
-};
-
-auto fd = [](auto&& data, auto&&... args) {
-  return stan::math::reduce_sum<sum_lpdf>(data, 0, msgs, args...);
-};
-
-TEST(MathMix_reduce_sum, int_arg) {
-  std::vector<double> data(2, 1.0);
-  int arg = 5.0;
-
-  stan::test::expect_ad([&](auto&& data) { return fd(data, arg); }, data);
-}
-
-TEST(MathMix_reduce_sum, double_arg) {
-  std::vector<double> data(2, 10.0);
-  double arg = 5.0;
-
-  stan::test::expect_ad(fi, arg);
-  stan::test::expect_ad(fd, data, arg);
-}
-
-TEST(MathMix_reduce_sum, std_vector_int_arg) {
-  std::vector<double> data(2, 10.0);
-  std::vector<int> arg(2, 10);
-
-  stan::test::expect_ad([&](auto&& data) { return fd(data, arg); }, data);
-}
-
-TEST(MathMix_reduce_sum, std_vector_double_arg) {
-  std::vector<double> data(2, 10.0);
-  std::vector<double> arg(2, 10.0);
-
-  stan::test::expect_ad(fi, arg);
-  stan::test::expect_ad(fd, data, arg);
-}
-
-TEST(MathMix_reduce_sum, eigen_vector_arg) {
-  std::vector<double> data(2, 10.0);
-  Eigen::VectorXd arg = Eigen::VectorXd::Ones(2);
-
-  stan::test::expect_ad(fi, arg);
-  stan::test::expect_ad(fd, data, arg);
-}
-
-TEST(MathMix_reduce_sum, eigen_row_vector_arg) {
-  std::vector<double> data(2, 10.0);
-  Eigen::RowVectorXd arg = Eigen::RowVectorXd::Ones(2);
-
-  stan::test::expect_ad(fi, arg);
-  stan::test::expect_ad(fd, data, arg);
-}
-
-TEST(MathMix_reduce_sum, eigen_matrix_arg) {
-  std::vector<double> data(2, 10.0);
-  Eigen::MatrixXd arg = Eigen::MatrixXd::Ones(2, 2);
-
-  stan::test::expect_ad(fi, arg);
-  stan::test::expect_ad(fd, data, arg);
-}
-
-TEST(MathMix_reduce_sum, std_vector_std_vector_double_arg) {
-  std::vector<double> data(2, 10.0);
-  std::vector<std::vector<double>> arg(2, std::vector<double>(2, 10.0));
-
-  stan::test::expect_ad(fi, arg);
-  stan::test::expect_ad(fd, data, arg);
-}
-
-TEST(MathMix_reduce_sum, std_vector_eigen_vector_arg) {
-  std::vector<double> data(2, 10.0);
-  std::vector<Eigen::VectorXd> arg(2, Eigen::VectorXd::Ones(2));
-
-  stan::test::expect_ad(fi, arg);
-  stan::test::expect_ad(fd, data, arg);
-}
-
-TEST(MathMix_reduce_sum, eigen_three_args1) {
-  Eigen::VectorXd arg1 = Eigen::VectorXd::Ones(2);
-  Eigen::RowVectorXd arg2 = Eigen::RowVectorXd::Ones(2);
-  Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
-
-  stan::test::expect_ad(fi, arg1, arg2, arg3);
-}
-
-TEST(MathMix_reduce_sum, eigen_three_args2) {
-  double arg1 = 1.0;
-  std::vector<double> arg2(2, 1.0);
-  Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
-
-  stan::test::expect_ad(fi, arg1, arg2, arg3);
-}
-
-TEST(MathMix_reduce_sum, eigen_three_args3) {
-  double arg1 = 1.0;
-  std::vector<std::vector<double>> arg2(2, std::vector<double>(2, 1.0));
-  std::vector<Eigen::MatrixXd> arg3(2, Eigen::MatrixXd::Ones(2, 2));
-
-  stan::test::expect_ad(fi, arg1, arg2, arg3);
-}
-
-TEST(MathMix_reduce_sum, eigen_three_args_with_ints1) {
-  Eigen::VectorXd arg1 = Eigen::VectorXd::Ones(2);
-  Eigen::RowVectorXd arg2 = Eigen::RowVectorXd::Ones(2);
-  Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
-
-  stan::test::expect_ad(
-      [&](auto&& arg1, auto&& arg2, auto&& arg3) {
-        return fi(1, arg1, std::vector<int>{1, 2, 3}, arg2, 3, arg3);
-      },
-      arg1, arg2, arg3);
-}
-
-TEST(MathMix_reduce_sum, eigen_three_args_with_ints2) {
-  double arg1 = 1.0;
-  std::vector<double> arg2(2, 1.0);
-  Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
-
-  stan::test::expect_ad(
-      [&](auto&& arg1, auto&& arg2, auto&& arg3) {
-        return fi(1, arg1, std::vector<int>{1, 2, 3}, arg2, 3, arg3);
-      },
-      arg1, arg2, arg3);
-}
-
-TEST(MathMix_reduce_sum, eigen_three_args_with_ints3) {
-  double arg1 = 1.0;
-  std::vector<std::vector<double>> arg2(2, std::vector<double>(2, 1.0));
-  std::vector<Eigen::MatrixXd> arg3(2, Eigen::MatrixXd::Ones(2, 2));
-
-  stan::test::expect_ad(
-      [&](auto&& arg1, auto&& arg2, auto&& arg3) {
-        return fi(1, arg1, std::vector<int>{1, 2, 3}, arg2, 3, arg3);
-      },
-      arg1, arg2, arg3);
-}
-
-TEST(MathMix_reduce_sum, eigen_three_args_with_doubles1) {
-  Eigen::VectorXd arg1 = Eigen::VectorXd::Ones(2);
-  Eigen::RowVectorXd arg2 = Eigen::RowVectorXd::Ones(2);
-  Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
-
-  stan::test::expect_ad(
-      [&](auto&& arg1, auto&& arg2, auto&& arg3) {
-        return fi(std::vector<double>{1.0, 2.0, 3.0}, arg1, 3.0, arg2,
-                  std::vector<double>{1.0, 2.0, 3.0}, arg3);
-      },
-      arg1, arg2, arg3);
-}
-
-TEST(MathMix_reduce_sum, eigen_three_args_with_doubles2) {
-  double arg1 = 1.0;
-  std::vector<double> arg2(2, 1.0);
-  Eigen::MatrixXd arg3 = Eigen::MatrixXd::Ones(2, 2);
-
-  stan::test::expect_ad(
-      [&](auto&& arg1, auto&& arg2, auto&& arg3) {
-        return fi(std::vector<double>{1.0, 2.0, 3.0}, arg1, 3.0, arg2,
-                  std::vector<double>{1.0, 2.0, 3.0}, arg3);
-      },
-      arg1, arg2, arg3);
-}
-
-TEST(MathMix_reduce_sum, eigen_three_args_with_doubles3) {
-  double arg1 = 1.0;
-  std::vector<std::vector<double>> arg2(2, std::vector<double>(2, 1.0));
-  std::vector<Eigen::MatrixXd> arg3(2, Eigen::MatrixXd::Ones(2, 2));
-
-  stan::test::expect_ad(
-      [&](auto&& arg1, auto&& arg2, auto&& arg3) {
-        return fi(std::vector<double>{1.0, 2.0, 3.0}, arg1, 3.0, arg2,
-                  std::vector<double>{1.0, 2.0, 3.0}, arg3);
-      },
-      arg1, arg2, arg3);
-}
diff --git a/test/unit/math/rev/functor/reduce_sum_test.cpp b/test/unit/math/rev/functor/reduce_sum_test.cpp
index 8615f90826f..b2f0212489e 100644
--- a/test/unit/math/rev/functor/reduce_sum_test.cpp
+++ b/test/unit/math/rev/functor/reduce_sum_test.cpp
@@ -223,7 +223,7 @@ TEST(StanMathRev_reduce_sum, grouped_gradient) {
   var lambda_v = vlambda_v[0];
 
   var poisson_lpdf = stan::math::reduce_sum<grouped_count_lpdf<var>>(
-      data, 5, msgs, vlambda_v, gidx);
+      data, 5, get_new_msg(), vlambda_v, gidx);
 
   std::vector<var> vref_lambda_v;
   for (std::size_t i = 0; i != elems; ++i) {

From a3a3121c8ffa717b2e19d4b52b15ee4f61f6e56b Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 13 Apr 2020 10:46:33 -0400
Subject: [PATCH 105/189] Cleaning up merge (Issue #1833)

---
 stan/math/prim/functor.hpp                    |  1 -
 stan/math/prim/functor/left_fold.hpp          | 41 ----------
 stan/math/prim/meta/broadcast_array.hpp       | 37 +++------
 stan/math/prim/meta/operands_and_partials.hpp |  1 +
 stan/math/rev/fun.hpp                         |  2 -
 stan/math/rev/fun/accumulate_adjoints.hpp     | 75 -------------------
 stan/math/rev/fun/deep_copy.hpp               | 50 -------------
 stan/math/rev/fun/save_varis.hpp              | 72 ------------------
 8 files changed, 12 insertions(+), 267 deletions(-)
 delete mode 100644 stan/math/prim/functor/left_fold.hpp
 delete mode 100644 stan/math/rev/fun/accumulate_adjoints.hpp
 delete mode 100644 stan/math/rev/fun/deep_copy.hpp
 delete mode 100644 stan/math/rev/fun/save_varis.hpp

diff --git a/stan/math/prim/functor.hpp b/stan/math/prim/functor.hpp
index 7a326490b8e..80719ace75e 100644
--- a/stan/math/prim/functor.hpp
+++ b/stan/math/prim/functor.hpp
@@ -11,7 +11,6 @@
 #include <stan/math/prim/functor/integrate_1d.hpp>
 #include <stan/math/prim/functor/integrate_ode_rk45.hpp>
 #include <stan/math/prim/functor/ode_rk45.hpp>
-#include <stan/math/prim/functor/left_fold.hpp>
 #include <stan/math/prim/functor/map_rect.hpp>
 #include <stan/math/prim/functor/map_rect_combine.hpp>
 #include <stan/math/prim/functor/map_rect_concurrent.hpp>
diff --git a/stan/math/prim/functor/left_fold.hpp b/stan/math/prim/functor/left_fold.hpp
deleted file mode 100644
index 4373e92b95b..00000000000
--- a/stan/math/prim/functor/left_fold.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-#ifndef STAN_MATH_PRIM_SCAL_FUNCTOR_LEFT_FOLD_HPP
-#define STAN_MATH_PRIM_SCAL_FUNCTOR_LEFT_FOLD_HPP
-
-#include <stan/math/prim/meta.hpp>
-#include <functional>
-#include <tuple>
-#include <utility>
-
-namespace stan {
-namespace math {
-
-/**
- * Performs a left fold on a tuple with a given operation
- * @tparam index The index in this recursion for accessing tuple elemenTypes
- * @tparam Op An operation to perform on the tuple elemenTypes
- * @tparam Types types of tuple elements
- * @param op operation to perform on individual tuple elements
- * @param t A tuple to iterate over
- */
-template <size_t index, class Op, class... Types>
-constexpr auto left_fold(Op op, const std::tuple<Types...>& t) {
-  if (index == sizeof...(Types) - 1) {
-    return std::get<index>(t);
-  } else {
-    return op(std::get<index>(t), left_fold<1 + index>(op, t));
-  }
-}
-
-/**
- * Sum the elements of a tuple
- * @tparam Types types of the tuple's elements
- * @param t tuple whose elements are to be summed
- */
-template <typename... Types, require_stan_scalar_t<Types>...>
-constexpr auto sum(const std::tuple<Types...>& t) {
-  return left_fold<0>(std::plus<>{}, t);
-}
-
-}  // namespace math
-}  // namespace stan
-#endif
diff --git a/stan/math/prim/meta/broadcast_array.hpp b/stan/math/prim/meta/broadcast_array.hpp
index efee520464a..3c92f4e139b 100644
--- a/stan/math/prim/meta/broadcast_array.hpp
+++ b/stan/math/prim/meta/broadcast_array.hpp
@@ -13,14 +13,12 @@ namespace internal {
 template <typename T>
 class broadcast_array {
  private:
-  using T_decay = std::decay_t<T>;
-  T_decay& prim_;
+  T& prim_;
 
  public:
   explicit broadcast_array(T& prim) : prim_(prim) {}
 
-  auto& operator[](int /*i*/) { return prim_; }
-  auto& operator[](int /*i*/) const { return prim_; }
+  T& operator[](int /*i*/) { return prim_; }
 
   /** \ingroup type_trait
    * We can assign any right hand side which allows for indexing to a
@@ -32,35 +30,22 @@ class broadcast_array {
   void operator=(const Y& m) {
     prim_ = m[0];
   }
-  broadcast_array& operator=(broadcast_array& other) {
-    prim_ = other.prim_;
-    return *this;
-  }
 };
 
 template <typename T, typename S, typename Enable = void>
 class empty_broadcast_array {
-  using T_decay = std::decay_t<T>;
-
  public:
   empty_broadcast_array() {}
   /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
-  T_decay& operator[](int /*i*/);
-  T_decay& operator[](int /*i*/) const;
+  T& operator[](int /*i*/);
 
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
   template <typename Y>
   void operator=(const Y& /*A*/);
-
-  /**
-   * Not implemented so cannot be called.
-   */
-  template <typename R>
-  void operator+=(R);
 };
 
 template <typename ViewElt, typename T>
@@ -70,31 +55,31 @@ class empty_broadcast_array<ViewElt, T, require_eigen_t<T>> {
 
  public:
   empty_broadcast_array() {}
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
   ViewElt& operator[](int /*i*/);
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
   ViewElt& operator()(int /*i*/);
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
   void operator=(const T_arg& /*A*/);
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
   void operator+=(T_arg /*A*/);
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
   void operator-=(T_arg /*A*/);
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
   T& row(int /*i*/);
-  /**
+  /** \ingroup type_trait
    * Not implemented so cannot be called.
    */
   T& col(int /*i*/);
diff --git a/stan/math/prim/meta/operands_and_partials.hpp b/stan/math/prim/meta/operands_and_partials.hpp
index b553b9ee0a6..19d4d0febab 100644
--- a/stan/math/prim/meta/operands_and_partials.hpp
+++ b/stan/math/prim/meta/operands_and_partials.hpp
@@ -2,6 +2,7 @@
 #define STAN_MATH_PRIM_META_OPERANDS_AND_PARTIALS_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/meta/require_generics.hpp>
 #include <stan/math/prim/meta/broadcast_array.hpp>
 #include <stan/math/prim/meta/return_type.hpp>
 #include <vector>
diff --git a/stan/math/rev/fun.hpp b/stan/math/rev/fun.hpp
index 9436ec452f0..3dd22962080 100644
--- a/stan/math/rev/fun.hpp
+++ b/stan/math/rev/fun.hpp
@@ -10,7 +10,6 @@
 #include <stan/math/rev/fun/Phi.hpp>
 #include <stan/math/rev/fun/Phi_approx.hpp>
 #include <stan/math/rev/fun/abs.hpp>
-#include <stan/math/rev/fun/accumulate_adjoints.hpp>
 #include <stan/math/rev/fun/acos.hpp>
 #include <stan/math/rev/fun/acosh.hpp>
 #include <stan/math/rev/fun/as_bool.hpp>
@@ -119,7 +118,6 @@
 #include <stan/math/rev/fun/rising_factorial.hpp>
 #include <stan/math/rev/fun/round.hpp>
 #include <stan/math/rev/fun/rows_dot_product.hpp>
-#include <stan/math/rev/fun/save_varis.hpp>
 #include <stan/math/rev/fun/sd.hpp>
 #include <stan/math/rev/fun/simplex_constrain.hpp>
 #include <stan/math/rev/fun/sin.hpp>
diff --git a/stan/math/rev/fun/accumulate_adjoints.hpp b/stan/math/rev/fun/accumulate_adjoints.hpp
deleted file mode 100644
index d3bf86494f5..00000000000
--- a/stan/math/rev/fun/accumulate_adjoints.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#ifndef STAN_MATH_REV_FUN_ACCUMULATE_ADJOINTS_HPP
-#define STAN_MATH_REV_FUN_ACCUMULATE_ADJOINTS_HPP
-
-#include <stan/math/rev/meta.hpp>
-#include <stan/math/rev/core.hpp>
-#include <cmath>
-
-namespace stan {
-namespace math {
-
-namespace internal {
-
-inline double* accumulate_adjoints(double* x) { return x; }
-
-template <typename... Pargs>
-double* accumulate_adjoints(double* dest, const var& x, const Pargs&... args);
-
-template <typename... Pargs>
-double* accumulate_adjoints(double* dest, const std::vector<var>& x,
-                            const Pargs&... args);
-
-template <typename T, require_t<is_var<scalar_type_t<T>>>..., typename... Pargs>
-double* accumulate_adjoints(double* dest, const std::vector<T>& x,
-                            const Pargs&... args);
-
-template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
-double* accumulate_adjoints(double* dest, const Mat& x, const Pargs&... args);
-
-template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>...,
-          typename... Pargs>
-double* accumulate_adjoints(double* dest, Arith&& x, const Pargs&... args);
-
-template <typename... Pargs>
-double* accumulate_adjoints(double* dest, const var& x, const Pargs&... args) {
-  *dest += x.adj();
-  return accumulate_adjoints(dest + 1, args...);
-}
-
-template <typename... Pargs>
-double* accumulate_adjoints(double* dest, const std::vector<var>& x,
-                            const Pargs&... args) {
-  for (size_t i = 0; i < x.size(); ++i) {
-    dest[i] += x[i].adj();
-  }
-  return accumulate_adjoints(dest + x.size(), args...);
-}
-
-template <typename T, require_t<is_var<scalar_type_t<T>>>..., typename... Pargs>
-double* accumulate_adjoints(double* dest, const std::vector<T>& x,
-                            const Pargs&... args) {
-  for (size_t i = 0; i < x.size(); ++i) {
-    dest = accumulate_adjoints(dest, x[i]);
-  }
-  return accumulate_adjoints(dest, args...);
-}
-
-template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
-double* accumulate_adjoints(double* dest, const Mat& x, const Pargs&... args) {
-  for (size_t i = 0; i < x.size(); ++i) {
-    dest[i] += x(i).adj();
-  }
-  return accumulate_adjoints(dest + x.size(), args...);
-}
-
-template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>...,
-          typename... Pargs>
-double* accumulate_adjoints(double* dest, Arith&& x, const Pargs&... args) {
-  return accumulate_adjoints(dest, args...);
-}
-
-}  // namespace internal
-
-}  // namespace math
-}  // namespace stan
-#endif
diff --git a/stan/math/rev/fun/deep_copy.hpp b/stan/math/rev/fun/deep_copy.hpp
deleted file mode 100644
index eb0e005cf0c..00000000000
--- a/stan/math/rev/fun/deep_copy.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef STAN_MATH_REV_FUN_DEEP_COPY_HPP
-#define STAN_MATH_REV_FUN_DEEP_COPY_HPP
-
-#include <stan/math/rev/meta.hpp>
-#include <stan/math/rev/core.hpp>
-#include <cmath>
-
-namespace stan {
-namespace math {
-
-namespace internal {
-
-template <typename T, require_arithmetic_t<scalar_type_t<T>>...>
-inline const T& deep_copy(const T& arg) {
-  return arg;
-}
-
-inline var deep_copy(const var& arg) { return var(new vari(arg.val(), false)); }
-
-inline std::vector<var> deep_copy(const std::vector<var>& arg) {
-  std::vector<var> copy(arg.size());
-  for (size_t i = 0; i < arg.size(); ++i) {
-    copy[i] = new vari(arg[i].val(), false);
-  }
-  return copy;
-}
-
-template <typename T, require_t<is_var<scalar_type_t<T>>>...>
-inline std::vector<T> deep_copy(const std::vector<T>& arg) {
-  std::vector<T> copy(arg.size());
-  for (size_t i = 0; i < arg.size(); ++i) {
-    copy[i] = deep_copy(arg[i]);
-  }
-  return copy;
-}
-
-template <int RowType, int ColType>
-inline Eigen::Matrix<var, RowType, ColType> deep_copy(
-    const Eigen::Matrix<var, RowType, ColType>& arg) {
-  Eigen::Matrix<var, RowType, ColType> copy(arg.rows(), arg.cols());
-  for (size_t i = 0; i < arg.size(); ++i) {
-    copy(i) = new vari(arg(i).val(), false);
-  }
-  return copy;
-}
-}  // namespace internal
-
-}  // namespace math
-}  // namespace stan
-#endif
diff --git a/stan/math/rev/fun/save_varis.hpp b/stan/math/rev/fun/save_varis.hpp
deleted file mode 100644
index d0ac38e99c3..00000000000
--- a/stan/math/rev/fun/save_varis.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-#ifndef STAN_MATH_REV_FUN_SAVE_VARIS_HPP
-#define STAN_MATH_REV_FUN_SAVE_VARIS_HPP
-
-#include <stan/math/rev/meta.hpp>
-#include <stan/math/rev/core.hpp>
-#include <cmath>
-
-namespace stan {
-namespace math {
-
-namespace internal {
-
-inline vari** save_varis(vari** dest) { return dest; }
-
-template <typename... Pargs>
-vari** save_varis(vari** dest, const var& x, const Pargs&... args);
-
-template <typename... Pargs>
-vari** save_varis(vari** dest, const std::vector<var>& x, const Pargs&... args);
-
-template <typename T, require_t<is_var<scalar_type_t<T>>>..., typename... Pargs>
-vari** save_varis(vari** dest, const std::vector<T>& x, const Pargs&... args);
-
-template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
-vari** save_varis(vari** dest, const Mat& x, const Pargs&... args);
-
-template <typename R, require_arithmetic_t<scalar_type_t<R>>...,
-          typename... Pargs>
-vari** save_varis(vari** dest, const R& x, const Pargs&... args);
-
-template <typename... Pargs>
-vari** save_varis(vari** dest, const var& x, const Pargs&... args) {
-  *dest = x.vi_;
-  return save_varis(dest + 1, args...);
-}
-
-template <typename... Pargs>
-vari** save_varis(vari** dest, const std::vector<var>& x,
-                  const Pargs&... args) {
-  for (size_t i = 0; i < x.size(); ++i) {
-    dest[i] = x[i].vi_;
-  }
-  return save_varis(dest + x.size(), args...);
-}
-
-template <typename T, require_t<is_var<scalar_type_t<T>>>..., typename... Pargs>
-vari** save_varis(vari** dest, const std::vector<T>& x, const Pargs&... args) {
-  for (size_t i = 0; i < x.size(); ++i) {
-    dest = save_varis(dest, x[i]);
-  }
-  return save_varis(dest, args...);
-}
-
-template <typename... Pargs, typename Mat, require_eigen_vt<is_var, Mat>...>
-vari** save_varis(vari** dest, const Mat& x, const Pargs&... args) {
-  for (size_t i = 0; i < x.size(); ++i) {
-    dest[i] = x(i).vi_;
-  }
-  return save_varis(dest + x.size(), args...);
-}
-
-template <typename R, require_arithmetic_t<scalar_type_t<R>>...,
-          typename... Pargs>
-vari** save_varis(vari** dest, const R& x, const Pargs&... args) {
-  return save_varis(dest, args...);
-}
-
-}  // namespace internal
-
-}  // namespace math
-}  // namespace stan
-#endif

From 7a8e3d5af1fb965ec7eb6b24b33ffee5d73553fc Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 13 Apr 2020 10:48:25 -0400
Subject: [PATCH 106/189] Cleaning up merge (reverting Jenkinsfile to develop)
 (Issue #1833)

---
 Jenkinsfile | 2 --
 1 file changed, 2 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index 79e04296df8..b039a14c314 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -240,7 +240,6 @@ pipeline {
                     steps {
                         deleteDir()
                         unstash 'MathSetup'
-                        sh "export STAN_NUM_THREADS=2"
                         sh "echo CXX=${env.CXX} -Werror > make/local"
                         sh "echo CPPFLAGS+=-DSTAN_THREADS >> make/local"
                         sh "export STAN_NUM_THREADS=4"
@@ -265,7 +264,6 @@ pipeline {
                     steps {
                         deleteDirWin()
                         unstash 'MathSetup'
-                        bat "setx STAN_NUM_THREADS 2"
                         bat "echo CXX=${env.CXX} -Werror > make/local"
                         bat "echo CXXFLAGS+=-DSTAN_THREADS >> make/local"
                         runTestsWin("test/unit -f thread")

From e012d1f36dfeeaeea80e8621c2ac48f55c1c31a2 Mon Sep 17 00:00:00 2001
From: rok-cesnovar <rok.cesnovar@fri.uni-lj.si>
Date: Fri, 24 Apr 2020 13:53:34 +0200
Subject: [PATCH 107/189] 2 missing inlines

---
 stan/math/rev/functor/ode_add_time_gradients.hpp | 8 ++++----
 stan/math/rev/functor/ode_bdf.hpp                | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/stan/math/rev/functor/ode_add_time_gradients.hpp b/stan/math/rev/functor/ode_add_time_gradients.hpp
index dfac7e5c75a..90777d4045e 100644
--- a/stan/math/rev/functor/ode_add_time_gradients.hpp
+++ b/stan/math/rev/functor/ode_add_time_gradients.hpp
@@ -9,19 +9,19 @@
 namespace stan {
 namespace math {
 namespace internal {
-double ode_time_gradient_var(double t, double grad) {
+inline double ode_time_gradient_var(double t, double grad) {
   invalid_argument("ode_time_gradient_var", "t", t,
                    "t must be of type var, not double");
   return 0.0;
 }
 
-var ode_time_gradient_var(var t, double grad) {
+inline var ode_time_gradient_var(var t, double grad) {
   return var(new precomp_v_vari(0.0, t.vi_, grad));
 }
 };  // namespace internal
 
 template <typename F, typename T_initial, typename T_out, typename... T_Args>
-auto ode_add_time_gradients(const F& f, const std::vector<T_initial>& y0,
+inline auto ode_add_time_gradients(const F& f, const std::vector<T_initial>& y0,
                             double t0, const std::vector<double>& ts,
                             const std::vector<std::vector<T_out>>& y,
                             std::ostream* msgs, const T_Args&... args) {
@@ -30,7 +30,7 @@ auto ode_add_time_gradients(const F& f, const std::vector<T_initial>& y0,
 
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename T_out, typename... T_Args>
-std::vector<std::vector<var>> ode_add_time_gradients(
+inline std::vector<std::vector<var>> ode_add_time_gradients(
     const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
     const std::vector<T_ts>& ts, const std::vector<std::vector<T_out>>& y,
     std::ostream* msgs, const T_Args&... args) {
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index e6438b5389e..fb36dff9cc9 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -40,7 +40,7 @@ ode_bdf_tol(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
       max_num_steps, msgs, args...);
 
   auto y = integrator.integrate();
-
+  
   return ode_add_time_gradients(f, y0, t0, ts, y, msgs, args...);
 }
 

From 03756de79a1f8d62e38878664b25156feb883687 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Wed, 6 May 2020 17:58:22 -0400
Subject: [PATCH 108/189] Switched ODE states to be expressed as Eigen Vectors
 (variadic odes, design-doc #19)

---
 .../math/prim/fun/ode_store_sensitivities.hpp |  6 +--
 stan/math/prim/functor.hpp                    |  1 +
 stan/math/prim/functor/coupled_ode_system.hpp | 10 ++---
 stan/math/prim/functor/integrate_ode_rk45.hpp | 13 +++++-
 ...grate_ode_std_vector_interface_adapter.hpp | 36 +++++++++++++++
 stan/math/prim/functor/ode_rk45.hpp           | 25 ++++++-----
 stan/math/rev/fun/ode_store_sensitivities.hpp | 16 +++----
 stan/math/rev/functor/coupled_ode_system.hpp  | 31 +++++++------
 stan/math/rev/functor/cvodes_integrator.hpp   | 43 +++++++++---------
 stan/math/rev/functor/integrate_ode_bdf.hpp   | 14 +++++-
 .../rev/functor/ode_add_time_gradients.hpp    | 30 +++++++------
 stan/math/rev/functor/ode_bdf.hpp             | 16 ++++---
 stan/math/rev/functor/ode_rk45.hpp            | 16 +++----
 .../functor/integrate_ode_rk45_grad_test.cpp  |  4 +-
 .../math/rev/functor/ode_bdf_prim_test.cpp    | 45 ++++++++++++-------
 15 files changed, 194 insertions(+), 112 deletions(-)
 create mode 100644 stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp

diff --git a/stan/math/prim/fun/ode_store_sensitivities.hpp b/stan/math/prim/fun/ode_store_sensitivities.hpp
index 06e57c8d804..d0b5e781e3c 100644
--- a/stan/math/prim/fun/ode_store_sensitivities.hpp
+++ b/stan/math/prim/fun/ode_store_sensitivities.hpp
@@ -10,11 +10,9 @@ namespace math {
 
 template <typename... Args,
           typename = require_all_arithmetic_t<scalar_type_t<Args>...>>
-std::vector<double> ode_store_sensitivities(
-    const std::vector<double>& coupled_state, const std::vector<double>& y0,
+Eigen::VectorXd ode_store_sensitivities(const Eigen::VectorXd& coupled_state, const Eigen::VectorXd& y0,
     const Args&... args) {
-  return std::vector<double>(coupled_state.data(),
-                             coupled_state.data() + y0.size());
+  return coupled_state.head(y0.size());
 }
 
 }  // namespace math
diff --git a/stan/math/prim/functor.hpp b/stan/math/prim/functor.hpp
index 80719ace75e..13dc85abe05 100644
--- a/stan/math/prim/functor.hpp
+++ b/stan/math/prim/functor.hpp
@@ -10,6 +10,7 @@
 #include <stan/math/prim/functor/finite_diff_hessian_helper.hpp>
 #include <stan/math/prim/functor/integrate_1d.hpp>
 #include <stan/math/prim/functor/integrate_ode_rk45.hpp>
+#include <stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp>
 #include <stan/math/prim/functor/ode_rk45.hpp>
 #include <stan/math/prim/functor/map_rect.hpp>
 #include <stan/math/prim/functor/map_rect_combine.hpp>
diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
index 94e61288283..6f3e76f2c1b 100644
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -66,7 +66,7 @@ struct coupled_ode_system_impl;
 template <typename F, typename T_initial, typename... Args>
 struct coupled_ode_system_impl<true, F, T_initial, Args...> {
   const F& f_;
-  const std::vector<double>& y0_;
+  const Eigen::VectorXd& y0_;
   std::tuple<const Args&...> args_tuple_;
   const size_t N_;
   std::ostream* msgs_;
@@ -83,11 +83,11 @@ struct coupled_ode_system_impl<true, F, T_initial, Args...> {
    * @param[in] x_int integer data
    * @param[in, out] msgs stream for messages
    */
-  coupled_ode_system_impl(const F& f, const std::vector<double>& y0,
+  coupled_ode_system_impl(const F& f, const Eigen::VectorXd& y0,
                           std::ostream* msgs, const Args&... args)
       : f_(f), y0_(y0), args_tuple_(args...), N_(y0.size()), msgs_(msgs) {}
 
-  void operator()(const std::vector<double>& y, std::vector<double>& dy_dt,
+  void operator()(const Eigen::VectorXd& y, Eigen::VectorXd& dy_dt,
                   double t) const {
     dy_dt = apply([&](const Args&... args) { return f_(t, y, msgs_, args...); },
                   args_tuple_);
@@ -121,7 +121,7 @@ struct coupled_ode_system_impl<true, F, T_initial, Args...> {
    *   elements are all zero as these are the Jacobian wrt to the
    *   parameters at the initial time-point, which is zero.
    */
-  std::vector<double> initial_state() const { return value_of(y0_); }
+  Eigen::VectorXd initial_state() const { return value_of(y0_); }
 };
 
 template <typename F, typename T_initial, typename... Args>
@@ -129,7 +129,7 @@ struct coupled_ode_system
     : public coupled_ode_system_impl<
           std::is_arithmetic<return_type_t<T_initial, Args...>>::value, F,
           T_initial, Args...> {
-  coupled_ode_system(const F& f, const std::vector<T_initial>& y0,
+  coupled_ode_system(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
                      std::ostream* msgs, const Args&... args)
       : coupled_ode_system_impl<
             std::is_arithmetic<return_type_t<T_initial, Args...>>::value, F,
diff --git a/stan/math/prim/functor/integrate_ode_rk45.hpp b/stan/math/prim/functor/integrate_ode_rk45.hpp
index 947d8f1b36b..f478458081b 100644
--- a/stan/math/prim/functor/integrate_ode_rk45.hpp
+++ b/stan/math/prim/functor/integrate_ode_rk45.hpp
@@ -2,6 +2,7 @@
 #define STAN_MATH_PRIM_FUNCTOR_INTEGRATE_ODE_RK45_HPP
 
 #include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp>
 #include <stan/math/prim/functor/ode_rk45.hpp>
 #include <ostream>
 #include <vector>
@@ -66,8 +67,16 @@ integrate_ode_rk45(const F& f, const std::vector<T1>& y0, const T_t0& t0,
                    std::ostream* msgs = nullptr,
                    double relative_tolerance = 1e-6,
                    double absolute_tolerance = 1e-6, int max_num_steps = 1e6) {
-  return ode_rk45_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
-                      max_num_steps, msgs, theta, x, x_int);
+  internal::integrate_ode_std_vector_interface_adapter<F> f_adapted(f);
+  auto y = ode_rk45_tol(f_adapted, to_vector(y0), t0, ts,
+			relative_tolerance, absolute_tolerance,
+			max_num_steps, msgs, theta, x, x_int);
+
+  std::vector<std::vector<return_type_t<T1, T_param, T_t0, T_ts>>> y_converted;
+  for(size_t i = 0; i < y.size(); ++i)
+    y_converted.push_back(to_array_1d(y[i]));
+
+  return y_converted;
 }
 
 }  // namespace math
diff --git a/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp b/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp
new file mode 100644
index 00000000000..ffeb30958f4
--- /dev/null
+++ b/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp
@@ -0,0 +1,36 @@
+#ifndef STAN_MATH_PRIM_FUNCTOR_INTEGRATE_ODE_STD_VECTOR_INTERFACE_ADAPTER_HPP
+#define STAN_MATH_PRIM_FUNCTOR_INTEGRATE_ODE_STD_VECTOR_INTERFACE_ADAPTER_HPP
+
+#include <stan/math/prim/fun/to_array_1d.hpp>
+#include <stan/math/prim/fun/to_vector.hpp>
+#include <ostream>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+namespace internal {
+
+template <typename F>
+struct integrate_ode_std_vector_interface_adapter {
+  // NOTE: I made this copy by value because
+  //  this function might go out of scope in reverse mode
+  const F f_;
+
+  integrate_ode_std_vector_interface_adapter(const F& f) : f_(f) {
+  }
+  
+  template<typename T0, typename T1, typename T2>
+  auto operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y, std::ostream* msgs,
+		  const std::vector<T2>& theta, const std::vector<double>& x,
+		  const std::vector<int>& x_int) const {
+    return to_vector(f_(t, to_array_1d(y), msgs, theta, x, x_int));
+  }
+};
+
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index 86d3b68865f..d063055595c 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -4,6 +4,7 @@
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/functor/coupled_ode_system.hpp>
 #include <stan/math/prim/fun/ode_store_sensitivities.hpp>
+#include <boost/numeric/odeint/external/eigen/eigen_algebra.hpp>
 #include <boost/numeric/odeint.hpp>
 #include <ostream>
 #include <vector>
@@ -12,8 +13,8 @@ namespace stan {
 namespace math {
 
 template <typename F, typename T_initial, typename... Args>
-std::vector<std::vector<typename stan::return_type<T_initial, Args...>::type>>
-ode_rk45(const F& f, const std::vector<T_initial>& y0, double t0,
+std::vector<Eigen::Matrix<stan::return_type_t<T_initial, Args...>, Eigen::Dynamic, 1>>
+ode_rk45(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, double t0,
          const std::vector<double>& ts, std::ostream* msgs,
          const Args&... args) {
   double relative_tolerance = 1e-6;
@@ -25,8 +26,8 @@ ode_rk45(const F& f, const std::vector<T_initial>& y0, double t0,
 }
 
 template <typename F, typename T_initial, typename... Args>
-std::vector<std::vector<typename stan::return_type<T_initial, Args...>::type>>
-ode_rk45_tol(const F& f, const std::vector<T_initial>& y0, double t0,
+std::vector<Eigen::Matrix<stan::return_type_t<T_initial, Args...>, Eigen::Dynamic, 1>>
+ode_rk45_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, double t0,
              const std::vector<double>& ts, double relative_tolerance,
              double absolute_tolerance, long int max_num_steps,
              std::ostream* msgs, const Args&... args) {
@@ -34,6 +35,7 @@ ode_rk45_tol(const F& f, const std::vector<T_initial>& y0, double t0,
   using boost::numeric::odeint::make_dense_output;
   using boost::numeric::odeint::max_step_checker;
   using boost::numeric::odeint::runge_kutta_dopri5;
+  using boost::numeric::odeint::vector_space_algebra;
 
   const std::vector<double> ts_dbl = value_of(ts);
 
@@ -74,14 +76,14 @@ ode_rk45_tol(const F& f, const std::vector<T_initial>& y0, double t0,
   ts_vec[0] = t0;
   std::copy(ts_dbl.begin(), ts_dbl.end(), ts_vec.begin() + 1);
 
-  std::vector<std::vector<return_t>> y;
+  std::vector<Eigen::Matrix<return_t, Eigen::Dynamic, 1>> y;
   bool observer_initial_recorded = false;
   size_t time_index = 0;
 
   // avoid recording of the initial state which is included by the
   // conventions of odeint in the output
   auto filtered_observer
-      = [&](const std::vector<double>& coupled_state, double t) -> void {
+    = [&](const Eigen::VectorXd& coupled_state, double t) -> void {
     if (!observer_initial_recorded) {
       observer_initial_recorded = true;
       return;
@@ -91,15 +93,16 @@ ode_rk45_tol(const F& f, const std::vector<T_initial>& y0, double t0,
   };
 
   // the coupled system creates the coupled initial state
-  std::vector<double> initial_coupled_state = coupled_system.initial_state();
+  Eigen::VectorXd initial_coupled_state = coupled_system.initial_state();
 
   const double step_size = 0.1;
   integrate_times(
       make_dense_output(absolute_tolerance, relative_tolerance,
-                        runge_kutta_dopri5<std::vector<double>, double,
-                                           std::vector<double>, double>()),
-      std::ref(coupled_system), initial_coupled_state, std::begin(ts_vec),
-      std::end(ts_vec), step_size, filtered_observer,
+                        runge_kutta_dopri5<Eigen::VectorXd, double,
+			                   Eigen::VectorXd, double,
+			                   vector_space_algebra>()),
+      std::ref(coupled_system), initial_coupled_state,
+      std::begin(ts_vec), std::end(ts_vec), step_size, filtered_observer,
       max_step_checker(max_num_steps));
 
   return y;
diff --git a/stan/math/rev/fun/ode_store_sensitivities.hpp b/stan/math/rev/fun/ode_store_sensitivities.hpp
index 6ad16e145c8..2b47d15aa70 100644
--- a/stan/math/rev/fun/ode_store_sensitivities.hpp
+++ b/stan/math/rev/fun/ode_store_sensitivities.hpp
@@ -10,13 +10,13 @@ namespace stan {
 namespace math {
 
 template <typename T_initial, typename... Args>
-std::vector<var> ode_store_sensitivities(
-    const std::vector<double>& coupled_state, const std::vector<T_initial>& y0,
-    const Args&... args) {
+Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(const Eigen::VectorXd& coupled_state,
+							      const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+							      const Args&... args) {
   const size_t N = y0.size();
   const size_t y0_vars = count_vars(y0);
   const size_t args_vars = count_vars(args...);
-  std::vector<var> yt;
+  Eigen::Matrix<var, Eigen::Dynamic, 1> yt(N);
 
   for (size_t j = 0; j < N; j++) {
     const size_t total_vars = y0_vars + args_vars;
@@ -33,7 +33,7 @@ std::vector<var> ode_store_sensitivities(
     varis_ptr = save_varis(varis_ptr, y0);
     for (std::size_t k = 0; k < y0_vars; k++) {
       //*varis_ptr = y0[k].vi_;
-      *partials_ptr = coupled_state[N + y0_vars * k + j];
+      *partials_ptr = coupled_state(N + y0_vars * k + j);
       partials_ptr++;
     }
 
@@ -41,12 +41,12 @@ std::vector<var> ode_store_sensitivities(
     for (std::size_t k = 0; k < args_vars; k++) {
       // dy[j]_dtheta[k]
       // theta[k].vi_
-      *partials_ptr = coupled_state[N + N * y0_vars + N * k + j];
+      *partials_ptr = coupled_state(N + N * y0_vars + N * k + j);
       partials_ptr++;
     }
 
-    yt.emplace_back(new precomputed_gradients_vari(coupled_state[j], total_vars,
-                                                   varis, partials));
+    yt(j) = new precomputed_gradients_vari(coupled_state(j), total_vars,
+					   varis, partials);
   }
 
   return yt;
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index d4d897f8025..5168f5512ee 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -65,7 +65,7 @@ namespace math {
 template <typename F, typename T_initial, typename... Args>
 struct coupled_ode_system_impl<false, F, T_initial, Args...> {
   const F& f_;
-  const std::vector<T_initial>& y0_;
+  const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_;
   std::tuple<const Args&...> args_tuple_;
   const size_t y0_vars_;
   const size_t args_vars_;
@@ -84,7 +84,7 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
    * @param[in] x_int integer data
    * @param[in, out] msgs stream for messages
    */
-  coupled_ode_system_impl(const F& f, const std::vector<T_initial>& y0,
+  coupled_ode_system_impl(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
                           std::ostream* msgs, const Args&... args)
       : f_(f),
         y0_(y0),
@@ -108,14 +108,19 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
    * @throw exception if the base ode function does not return the
    *    expected number of derivatives, N.
    */
-  void operator()(const std::vector<double>& z, std::vector<double>& dz_dt,
+  void operator()(const Eigen::VectorXd& z, Eigen::VectorXd& dz_dt,
                   double t) const {
     using std::vector;
 
+    dz_dt.resize(size());
+    
     // Run nested autodiff in this scope
     nested_rev_autodiff nested;
 
-    const vector<var> y_vars(z.begin(), z.begin() + N_);
+    Eigen::Matrix<var, Eigen::Dynamic, 1> y_vars(N_);
+    for(size_t n = 0; n < N_; ++n)
+      y_vars(n) = z(n);
+
     auto local_args_tuple = apply(
         [&](auto&&... args) {
           return std::tuple<decltype(deep_copy_vars(args))...>(
@@ -123,16 +128,16 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
         },
         args_tuple_);
 
-    vector<var> f_y_t_vars
-        = apply([&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
-                local_args_tuple);
+    Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars
+      = apply([&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
+	      local_args_tuple);
 
     check_size_match("coupled_ode_system", "dy_dt", f_y_t_vars.size(), "states",
                      N_);
 
     for (size_t i = 0; i < N_; i++) {
-      dz_dt[i] = f_y_t_vars[i].val();
-      f_y_t_vars[i].grad();
+      dz_dt(i) = f_y_t_vars(i).val();
+      f_y_t_vars(i).grad();
       for (size_t j = 0; j < y0_vars_; j++) {
         // orders derivatives by equation (i.e. if there are 2 eqns
         // (y1, y2) and 2 parameters (a, b), dy_dt will be ordered as:
@@ -190,13 +195,13 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
    *   elements are all zero as these are the Jacobian wrt to the
    *   parameters at the initial time-point, which is zero.
    */
-  std::vector<double> initial_state() const {
-    std::vector<double> initial(size(), 0.0);
+  Eigen::VectorXd initial_state() const {
+    Eigen::VectorXd initial = Eigen::VectorXd::Zero(size());
     for (size_t i = 0; i < N_; i++) {
-      initial[i] = value_of(y0_[i]);
+      initial(i) = value_of(y0_[i]);
     }
     for (size_t i = 0; i < y0_vars_; i++) {
-      initial[N_ + i * N_ + i] = 1.0;
+      initial(N_ + i * N_ + i) = 1.0;
     }
     return initial;
   }
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 67243af78e1..74c9823f1ce 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -27,7 +27,7 @@ class cvodes_integrator {
   using T_Return = return_type_t<T_initial, T_Args...>;
 
   const F& f_;
-  const std::vector<T_initial>& y0_;
+  const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_;
   double t0_;
   const std::vector<double>& ts_;
   std::tuple<const T_Args&...> args_tuple_;
@@ -43,7 +43,7 @@ class cvodes_integrator {
 
   coupled_ode_system<F, T_initial, T_Args...> coupled_ode_;
 
-  std::vector<double> coupled_state_;
+  Eigen::VectorXd coupled_state_;
   N_Vector nv_state_;
   N_Vector* nv_state_sens_;
   SUNMatrix A_;
@@ -93,13 +93,16 @@ class cvodes_integrator {
    * the given time t and state y.
    */
   inline void rhs(double t, const double y[], double dy_dt[]) const {
-    const std::vector<double> y_vec(y, y + N_);
-    std::vector<double> dy_dt_vec
-        = apply([&](auto&&... args) { return f_(t, y_vec, msgs_, args...); },
-                value_of_args_tuple_);
+    const Eigen::VectorXd y_vec = Eigen::Map<const Eigen::VectorXd>(y, N_);
+
+    Eigen::VectorXd dy_dt_vec
+      = apply([&](auto&&... args) { return f_(t, y_vec, msgs_, args...); },
+	      value_of_args_tuple_);
+
     check_size_match("cvodes_integrator::rhs", "dy_dt", dy_dt_vec.size(),
                      "states", N_);
-    std::move(dy_dt_vec.begin(), dy_dt_vec.end(), dy_dt);
+
+    std::copy(dy_dt_vec.data(), dy_dt_vec.data() + dy_dt_vec.size(), dy_dt);
   }
 
   /**
@@ -111,9 +114,8 @@ class cvodes_integrator {
     Eigen::MatrixXd Jfy;
 
     auto f_wrapped = [&](const Eigen::Matrix<var, Eigen::Dynamic, 1>& y) {
-      return to_vector(apply(
-          [&](auto&&... args) { return f_(t, to_array_1d(y), msgs_, args...); },
-          value_of_args_tuple_));
+      return apply([&](auto&&... args) { return f_(t, y, msgs_, args...); },
+          value_of_args_tuple_);
     };
 
     jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(y, N_), fy, Jfy);
@@ -133,24 +135,25 @@ class cvodes_integrator {
    */
   inline void rhs_sens(double t, const double y[], N_Vector* yS,
                        N_Vector* ySdot) const {
-    std::vector<double> z(coupled_state_.size());
-    std::vector<double>&& dz_dt = std::vector<double>(coupled_state_.size());
-    std::copy(y, y + N_, z.begin());
+    Eigen::VectorXd z(coupled_state_.size());
+    Eigen::VectorXd dz_dt(coupled_state_.size());
+    std::copy(y, y + N_, z.data());
     for (std::size_t s = 0; s < y0_vars_ + args_vars_; s++) {
       std::copy(NV_DATA_S(yS[s]), NV_DATA_S(yS[s]) + N_,
-                z.begin() + (s + 1) * N_);
+                z.data() + (s + 1) * N_);
     }
     coupled_ode_(z, dz_dt, t);
     for (std::size_t s = 0; s < y0_vars_ + args_vars_; s++) {
-      std::move(dz_dt.begin() + (s + 1) * N_, dz_dt.begin() + (s + 2) * N_,
+      std::move(dz_dt.data() + (s + 1) * N_, dz_dt.data() + (s + 2) * N_,
                 NV_DATA_S(ySdot[s]));
     }
   }
 
  public:
-  cvodes_integrator(const F& f, const std::vector<T_initial>& y0, double t0,
-                    const std::vector<double>& ts, double relative_tolerance,
-                    double absolute_tolerance, long int max_num_steps,
+  cvodes_integrator(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+		    double t0, const std::vector<double>& ts,
+		    double relative_tolerance, double absolute_tolerance,
+		    long int max_num_steps,
                     std::ostream* msgs, const T_Args&... args)
       : f_(f),
         y0_(y0),
@@ -255,8 +258,8 @@ class cvodes_integrator {
    * @return a vector of states, each state being a vector of the
    * same size as the state variable, corresponding to a time in ts.
    */
-  std::vector<std::vector<T_Return>> integrate() {  // NOLINT(runtime/int)
-    std::vector<std::vector<T_Return>> y;
+  std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> integrate() {  // NOLINT(runtime/int)
+    std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> y;
 
     const double t0_dbl = value_of(t0_);
     const std::vector<double> ts_dbl = value_of(ts_);
diff --git a/stan/math/rev/functor/integrate_ode_bdf.hpp b/stan/math/rev/functor/integrate_ode_bdf.hpp
index 6dd52ecdee6..723fea0e700 100644
--- a/stan/math/rev/functor/integrate_ode_bdf.hpp
+++ b/stan/math/rev/functor/integrate_ode_bdf.hpp
@@ -1,6 +1,8 @@
 #ifndef STAN_MATH_REV_FUNCTOR_INTEGRATE_ODE_BDF_HPP
 #define STAN_MATH_REV_FUNCTOR_INTEGRATE_ODE_BDF_HPP
 
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp>
 #include <stan/math/rev/functor/ode_bdf.hpp>
 #include <ostream>
 #include <vector>
@@ -19,8 +21,16 @@ integrate_ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
                   double relative_tolerance = 1e-10,
                   double absolute_tolerance = 1e-10,
                   long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
-  return ode_bdf_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
-                     max_num_steps, msgs, theta, x, x_int);
+  internal::integrate_ode_std_vector_interface_adapter<F> f_adapted(f);
+  auto y = ode_bdf_tol(f_adapted, to_vector(y0), t0, ts,
+		       relative_tolerance, absolute_tolerance,
+		       max_num_steps, msgs, theta, x, x_int);
+
+  std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>> y_converted;
+  for(size_t i = 0; i < y.size(); ++i)
+    y_converted.push_back(to_array_1d(y[i]));
+
+  return y_converted;
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/ode_add_time_gradients.hpp b/stan/math/rev/functor/ode_add_time_gradients.hpp
index dfac7e5c75a..e3c548a67b0 100644
--- a/stan/math/rev/functor/ode_add_time_gradients.hpp
+++ b/stan/math/rev/functor/ode_add_time_gradients.hpp
@@ -21,20 +21,21 @@ var ode_time_gradient_var(var t, double grad) {
 };  // namespace internal
 
 template <typename F, typename T_initial, typename T_out, typename... T_Args>
-auto ode_add_time_gradients(const F& f, const std::vector<T_initial>& y0,
+auto ode_add_time_gradients(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
                             double t0, const std::vector<double>& ts,
-                            const std::vector<std::vector<T_out>>& y,
+                            const std::vector<Eigen::Matrix<T_out, Eigen::Dynamic, 1>>& y,
                             std::ostream* msgs, const T_Args&... args) {
   return y;
 }
 
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename T_out, typename... T_Args>
-std::vector<std::vector<var>> ode_add_time_gradients(
-    const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
-    const std::vector<T_ts>& ts, const std::vector<std::vector<T_out>>& y,
-    std::ostream* msgs, const T_Args&... args) {
-  std::vector<double> f_y0_t0 = {};
+std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>>
+ode_add_time_gradients(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+		       const T_t0& t0, const std::vector<T_ts>& ts,
+		       const std::vector<Eigen::Matrix<T_out, Eigen::Dynamic, 1>>& y,
+		       std::ostream* msgs, const T_Args&... args) {
+  Eigen::VectorXd f_y0_t0;
   if (is_var<T_t0>::value) {
     f_y0_t0 = f(value_of(t0), value_of(y0), msgs, value_of(args)...);
 
@@ -42,23 +43,24 @@ std::vector<std::vector<var>> ode_add_time_gradients(
                      y0.size());
   }
 
-  std::vector<std::vector<var>> y_with_gradients(y.size());
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> y_with_gradients(y.size());
 
   for (size_t i = 0; i < y.size(); ++i) {
-    std::vector<double> f_y_t = {};
+    Eigen::VectorXd f_y_t;
+
+    y_with_gradients[i].resize(y[i].size());
+
     if (is_var<T_ts>::value)
       f_y_t = f(value_of(ts[i]), value_of(y[i]), msgs, value_of(args)...);
 
     for (size_t j = 0; j < y[i].size(); ++j) {
-      var tmp = y[i][j];
+      y_with_gradients[i](j) = y[i][j];
 
       if (is_var<T_t0>::value)
-        tmp += internal::ode_time_gradient_var(t0, -f_y0_t0[j]);
+        y_with_gradients[i](j) += internal::ode_time_gradient_var(t0, -f_y0_t0[j]);
 
       if (is_var<T_ts>::value)
-        tmp += internal::ode_time_gradient_var(ts[i], f_y_t[j]);
-
-      y_with_gradients[i].push_back(tmp);
+        y_with_gradients[i](j) += internal::ode_time_gradient_var(ts[i], f_y_t[j]);
     }
   }
 
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index e6438b5389e..e8309c098ef 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -12,9 +12,9 @@ namespace math {
 
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
-std::vector<std::vector<
-    typename stan::return_type<T_initial, T_t0, T_ts, T_Args...>::type>>
-ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
+std::vector<Eigen::Matrix<
+	      stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>, Eigen::Dynamic, 1>>
+ode_bdf(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, const T_t0& t0,
         const std::vector<T_ts>& ts, std::ostream* msgs,
         const T_Args&... args) {
   double relative_tolerance = 1e-6;
@@ -27,9 +27,9 @@ ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
 
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
-std::vector<std::vector<
-    typename stan::return_type<T_initial, T_t0, T_ts, T_Args...>::type>>
-ode_bdf_tol(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
+std::vector<Eigen::Matrix<
+	      stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>, Eigen::Dynamic, 1>>
+ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, const T_t0& t0,
             const std::vector<T_ts>& ts, double relative_tolerance,
             double absolute_tolerance, long int max_num_steps,
             std::ostream* msgs, const T_Args&... args) {
@@ -39,7 +39,9 @@ ode_bdf_tol(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
       f, y0, value_of(t0), value_of_ts, relative_tolerance, absolute_tolerance,
       max_num_steps, msgs, args...);
 
-  auto y = integrator.integrate();
+  std::vector<Eigen::Matrix<
+    stan::return_type_t<T_initial, T_Args...>, Eigen::Dynamic, 1>>
+    y = integrator.integrate();
 
   return ode_add_time_gradients(f, y0, t0, ts, y, msgs, args...);
 }
diff --git a/stan/math/rev/functor/ode_rk45.hpp b/stan/math/rev/functor/ode_rk45.hpp
index 8a3853d0f0a..61120d99e21 100644
--- a/stan/math/rev/functor/ode_rk45.hpp
+++ b/stan/math/rev/functor/ode_rk45.hpp
@@ -11,9 +11,9 @@ namespace math {
 
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
-std::vector<std::vector<var>> ode_rk45(
-    const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
-    const std::vector<T_ts>& ts, std::ostream* msgs, const T_Args&... args) {
+std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>>
+ode_rk45(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, const T_t0& t0,
+	 const std::vector<T_ts>& ts, std::ostream* msgs, const T_Args&... args) {
   double relative_tolerance = 1e-6;
   double absolute_tolerance = 1e-6;
   long int max_num_steps = 1e6;
@@ -24,11 +24,11 @@ std::vector<std::vector<var>> ode_rk45(
 
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
-std::vector<std::vector<var>> ode_rk45_tol(
-    const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
-    const std::vector<T_ts>& ts, double relative_tolerance,
-    double absolute_tolerance, long int max_num_steps, std::ostream* msgs,
-    const T_Args&... args) {
+std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>>
+ode_rk45_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, const T_t0& t0,
+	     const std::vector<T_ts>& ts, double relative_tolerance,
+	     double absolute_tolerance, long int max_num_steps, std::ostream* msgs,
+	     const T_Args&... args) {
   auto y = ode_rk45_tol(f, y0, value_of(t0), value_of(ts), relative_tolerance,
                         absolute_tolerance, max_num_steps, msgs, args...);
 
diff --git a/test/unit/math/rev/functor/integrate_ode_rk45_grad_test.cpp b/test/unit/math/rev/functor/integrate_ode_rk45_grad_test.cpp
index 942b62b3668..fafae56b3df 100644
--- a/test/unit/math/rev/functor/integrate_ode_rk45_grad_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_rk45_grad_test.cpp
@@ -38,9 +38,9 @@ class sho_functor {
   // parameters
   // double data
   // integer data
-  operator()(const T0& t_in, const std::vector<T1>& y_in,
+  operator()(const T0& t_in, const std::vector<T1>& y_in, std::ostream* msgs,
              const std::vector<T2>& theta, const std::vector<double>& x,
-             const std::vector<int>& x_int, std::ostream* msgs) const {
+             const std::vector<int>& x_int) const {
     if (y_in.size() != 2)
       throw std::domain_error("Functor called with inconsistent state");
 
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index 0b7cda95723..c59a954234e 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -29,34 +29,38 @@ auto sum_(Vec&& arg) {
 
 struct CosArg1 {
   template <typename T0, typename T1, typename... T_Args>
-  inline std::vector<stan::return_type_t<T1, T_Args...>> operator()(
-      const T0& t, const std::vector<T1>& y, std::ostream* msgs,
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> operator()(
+											 const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y, std::ostream* msgs,
       const T_Args&... a) const {
     std::vector<typename stan::return_type<T0, T_Args...>::type> vec
         = {sum_(a)...};
-    return {stan::math::cos(sum_(vec) * t)};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos(sum_(vec) * t);
+    return out;
   }
 };
 
 struct Cos2Arg {
   template <typename T0, typename T1, typename T2, typename T3>
-  inline std::vector<typename stan::return_type<T1, T2, T3>::type> operator()(
-      const T0& t, const std::vector<T1>& y, std::ostream* msgs, const T2& a,
+  inline Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1> operator()(
+										      const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y, std::ostream* msgs, const T2& a,
       const T3& b) const {
-    return {stan::math::cos((sum_(a) + sum_(b)) * t)};
+    Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos((sum_(a) + sum_(b)) * t);
+    return out;
   }
 };
 
 TEST(StanMathOde_ode_bdf_tol, t0) {
   using stan::math::var;
 
-  std::vector<double> y0 = {0.0};
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   var t0 = 0.0;
   std::vector<double> ts = {0.45, 1.1};
 
   double a = 1.5;
 
-  std::vector<std::vector<var>> output = stan::math::ode_bdf_tol(
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output = stan::math::ode_bdf_tol(
       CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
 
   output[0][0].grad();
@@ -75,13 +79,13 @@ TEST(StanMathOde_ode_bdf_tol, t0) {
 TEST(StanMathOde_ode_bdf_tol, ts) {
   using stan::math::var;
 
-  std::vector<double> y0 = {0.0};
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0.0;
   std::vector<var> ts = {0.45, 1.1};
 
   double a = 1.5;
 
-  std::vector<std::vector<var>> output = stan::math::ode_bdf_tol(
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output = stan::math::ode_bdf_tol(
       CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
 
   output[0][0].grad();
@@ -100,7 +104,7 @@ TEST(StanMathOde_ode_bdf_tol, ts) {
 TEST(StanMathOde_ode_bdf_tol, scalar_arg) {
   using stan::math::var;
 
-  std::vector<double> y0 = {0.0};
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0.0;
   std::vector<double> ts = {1.1};
 
@@ -118,7 +122,7 @@ TEST(StanMathOde_ode_bdf_tol, scalar_arg) {
 TEST(StanMathOde_ode_bdf_tol, std_vector_arg) {
   using stan::math::var;
 
-  std::vector<double> y0 = {0.0};
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0.0;
   std::vector<double> ts = {1.1};
 
@@ -136,7 +140,7 @@ TEST(StanMathOde_ode_bdf_tol, std_vector_arg) {
 TEST(StanMathOde_ode_bdf_tol, vector_arg) {
   using stan::math::var;
 
-  std::vector<double> y0 = {0.0};
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0.0;
   std::vector<double> ts = {1.1};
 
@@ -155,7 +159,7 @@ TEST(StanMathOde_ode_bdf_tol, vector_arg) {
 TEST(StanMathOde_ode_bdf_tol, row_vector_arg) {
   using stan::math::var;
 
-  std::vector<double> y0 = {0.0};
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0.0;
   std::vector<double> ts = {1.1};
 
@@ -174,7 +178,7 @@ TEST(StanMathOde_ode_bdf_tol, row_vector_arg) {
 TEST(StanMathOde_ode_bdf_tol, matrix_arg) {
   using stan::math::var;
 
-  std::vector<double> y0 = {0.0};
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0.0;
   std::vector<double> ts = {1.1};
 
@@ -193,7 +197,7 @@ TEST(StanMathOde_ode_bdf_tol, matrix_arg) {
 TEST(StanMathOde_ode_bdf_tol, scalar_std_vector_args) {
   using stan::math::var;
 
-  std::vector<double> y0 = {0.0};
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0.0;
   std::vector<double> ts = {1.1};
 
@@ -208,3 +212,12 @@ TEST(StanMathOde_ode_bdf_tol, scalar_std_vector_args) {
   EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
   EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
 }
+
+struct ayt {
+  template <typename T0, typename T1, typename T2>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1> operator()(
+	const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y, std::ostream* msgs,
+      const T2& a) const {
+    return -a * y * t;
+  }
+};

From 257afa0e077a9e1e18e9f445062132a066237988 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Sat, 9 May 2020 16:06:16 -0400
Subject: [PATCH 109/189] Fixed bug with how ode sensitivities with respect to
 t0 work (design-doc #19)

---
 .../math/prim/fun/ode_store_sensitivities.hpp |  11 +-
 stan/math/prim/functor/ode_rk45.hpp           |  30 +-
 stan/math/rev/fun/ode_store_sensitivities.hpp |  48 ++-
 stan/math/rev/functor.hpp                     |   2 -
 stan/math/rev/functor/cvodes_integrator.hpp   |  27 +-
 .../rev/functor/ode_add_time_gradients.hpp    |  72 ----
 stan/math/rev/functor/ode_bdf.hpp             |  11 +-
 stan/math/rev/functor/ode_rk45.hpp            |  40 ---
 .../functor/integrate_ode_bdf_rev_test.cpp    |  43 ++-
 .../functor/integrate_ode_rk45_rev_test.cpp   |  43 ++-
 ...bdf_prim_test.cpp => ode_bdf_rev_test.cpp} | 132 +++++++
 .../math/rev/functor/ode_rk45_prim_test.cpp   | 210 -----------
 .../math/rev/functor/ode_rk45_rev_test.cpp    | 338 ++++++++++++++++++
 13 files changed, 597 insertions(+), 410 deletions(-)
 delete mode 100644 stan/math/rev/functor/ode_add_time_gradients.hpp
 delete mode 100644 stan/math/rev/functor/ode_rk45.hpp
 rename test/unit/math/rev/functor/{ode_bdf_prim_test.cpp => ode_bdf_rev_test.cpp} (56%)
 delete mode 100644 test/unit/math/rev/functor/ode_rk45_prim_test.cpp
 create mode 100644 test/unit/math/rev/functor/ode_rk45_rev_test.cpp

diff --git a/stan/math/prim/fun/ode_store_sensitivities.hpp b/stan/math/prim/fun/ode_store_sensitivities.hpp
index d0b5e781e3c..2025fc2fb34 100644
--- a/stan/math/prim/fun/ode_store_sensitivities.hpp
+++ b/stan/math/prim/fun/ode_store_sensitivities.hpp
@@ -8,10 +8,15 @@
 namespace stan {
 namespace math {
 
-template <typename... Args,
+template <typename F, typename... Args,
           typename = require_all_arithmetic_t<scalar_type_t<Args>...>>
-Eigen::VectorXd ode_store_sensitivities(const Eigen::VectorXd& coupled_state, const Eigen::VectorXd& y0,
-    const Args&... args) {
+Eigen::VectorXd ode_store_sensitivities(const F& f,
+					const Eigen::VectorXd& coupled_state,
+					const Eigen::VectorXd& y0,
+					double t0,
+					double t,
+					std::ostream* msgs,
+					const Args&... args) {
   return coupled_state.head(y0.size());
 }
 
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index d063055595c..b220c15a372 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -12,7 +12,8 @@
 namespace stan {
 namespace math {
 
-template <typename F, typename T_initial, typename... Args>
+template <typename F, typename T_initial, typename T_t0, typename T_ts,
+	  typename... Args>
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, Args...>, Eigen::Dynamic, 1>>
 ode_rk45(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, double t0,
          const std::vector<double>& ts, std::ostream* msgs,
@@ -25,10 +26,12 @@ ode_rk45(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, doub
                       max_num_steps, msgs, args...);
 }
 
-template <typename F, typename T_initial, typename... Args>
-std::vector<Eigen::Matrix<stan::return_type_t<T_initial, Args...>, Eigen::Dynamic, 1>>
-ode_rk45_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, double t0,
-             const std::vector<double>& ts, double relative_tolerance,
+template <typename F, typename T_initial, typename T_t0, typename T_ts,
+	  typename... Args>
+std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, Args...>, Eigen::Dynamic, 1>>
+ode_rk45_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_arg,
+	     T_t0 t0,
+             const std::vector<T_ts>& ts, double relative_tolerance,
              double absolute_tolerance, long int max_num_steps,
              std::ostream* msgs, const Args&... args) {
   using boost::numeric::odeint::integrate_times;
@@ -37,6 +40,11 @@ ode_rk45_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
   using boost::numeric::odeint::runge_kutta_dopri5;
   using boost::numeric::odeint::vector_space_algebra;
 
+  using T_initial_or_t0 = return_type_t<T_initial, T_t0>;
+  
+  Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1> y0 = y0_arg.unaryExpr([](const T_initial& val) {
+      return T_initial_or_t0(val);
+    });
   const std::vector<double> ts_dbl = value_of(ts);
 
   check_finite("integrate_ode_rk45", "initial state", y0);
@@ -66,14 +74,14 @@ ode_rk45_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
                      ", must be greater than 0");
   }
 
-  using return_t = return_type_t<T_initial, Args...>;
+  using return_t = return_type_t<T_initial, T_t0, T_ts, Args...>;
   // creates basic or coupled system by template specializations
-  coupled_ode_system<F, T_initial, Args...> coupled_system(f, y0, msgs,
-                                                           args...);
+  coupled_ode_system<F, T_initial_or_t0, Args...> coupled_system(f, y0, msgs,
+								 args...);
 
   // first time in the vector must be time of initial state
   std::vector<double> ts_vec(ts.size() + 1);
-  ts_vec[0] = t0;
+  ts_vec[0] = value_of(t0);
   std::copy(ts_dbl.begin(), ts_dbl.end(), ts_vec.begin() + 1);
 
   std::vector<Eigen::Matrix<return_t, Eigen::Dynamic, 1>> y;
@@ -88,7 +96,9 @@ ode_rk45_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
       observer_initial_recorded = true;
       return;
     }
-    y.emplace_back(ode_store_sensitivities(coupled_state, y0, args...));
+    y.emplace_back(ode_store_sensitivities(f, coupled_state, y0,
+					   t0, ts[time_index],
+					   msgs, args...));
     time_index++;
   };
 
diff --git a/stan/math/rev/fun/ode_store_sensitivities.hpp b/stan/math/rev/fun/ode_store_sensitivities.hpp
index 2b47d15aa70..d7ea8aa0f3a 100644
--- a/stan/math/rev/fun/ode_store_sensitivities.hpp
+++ b/stan/math/rev/fun/ode_store_sensitivities.hpp
@@ -9,17 +9,33 @@
 namespace stan {
 namespace math {
 
-template <typename T_initial, typename... Args>
-Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(const Eigen::VectorXd& coupled_state,
-							      const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+template <typename F, typename T_initial_or_t0, typename T_t0, typename T_t, typename... Args>
+Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(const F& f,
+							      const Eigen::VectorXd& coupled_state,
+							      const Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1>& y0,
+							      const T_t0& t0,
+							      const T_t& t,
+							      std::ostream* msgs,
 							      const Args&... args) {
   const size_t N = y0.size();
   const size_t y0_vars = count_vars(y0);
   const size_t args_vars = count_vars(args...);
+  const size_t t0_vars = count_vars(t0);
+  const size_t t_vars = count_vars(t);
   Eigen::Matrix<var, Eigen::Dynamic, 1> yt(N);
 
+  Eigen::VectorXd y = coupled_state.head(N);
+  
+  Eigen::VectorXd f_y_t;
+  if (is_var<T_t>::value)
+    f_y_t = f(value_of(t), y, msgs, value_of(args)...);
+
+  Eigen::VectorXd f_y0_t0;
+  if (is_var<T_t0>::value)
+    f_y0_t0 = f(value_of(t0), value_of(y0), msgs, value_of(args)...);
+
   for (size_t j = 0; j < N; j++) {
-    const size_t total_vars = y0_vars + args_vars;
+    const size_t total_vars = y0_vars + args_vars + t0_vars + t_vars;
 
     vari** varis
         = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
@@ -31,21 +47,39 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(const Eigen::Vecto
 
     // iterate over parameters for each equation
     varis_ptr = save_varis(varis_ptr, y0);
-    for (std::size_t k = 0; k < y0_vars; k++) {
+    for (std::size_t k = 0; k < y0_vars; ++k) {
       //*varis_ptr = y0[k].vi_;
       *partials_ptr = coupled_state(N + y0_vars * k + j);
       partials_ptr++;
     }
 
     varis_ptr = save_varis(varis_ptr, args...);
-    for (std::size_t k = 0; k < args_vars; k++) {
+    for (std::size_t k = 0; k < args_vars; ++k) {
       // dy[j]_dtheta[k]
       // theta[k].vi_
       *partials_ptr = coupled_state(N + N * y0_vars + N * k + j);
       partials_ptr++;
     }
 
-    yt(j) = new precomputed_gradients_vari(coupled_state(j), total_vars,
+    varis_ptr = save_varis(varis_ptr, t0);
+    if(t0_vars > 0) {
+      double dyt_dt0 = 0.0;
+      for (std::size_t k = 0; k < y0_vars; ++k) {
+	// dy[j]_dtheta[k]
+	// theta[k].vi_
+	dyt_dt0 += -f_y0_t0[k] * coupled_state(N + y0_vars * k + j);
+      }
+      *partials_ptr = dyt_dt0;
+      partials_ptr++;
+    }
+
+    varis_ptr = save_varis(varis_ptr, t);
+    if(t_vars > 0) {
+      *partials_ptr = f_y_t[j];
+      partials_ptr++;
+    }
+
+    yt(j) = new precomputed_gradients_vari(y(j), total_vars,
 					   varis, partials);
   }
 
diff --git a/stan/math/rev/functor.hpp b/stan/math/rev/functor.hpp
index dc58245ab95..d1f31aef725 100644
--- a/stan/math/rev/functor.hpp
+++ b/stan/math/rev/functor.hpp
@@ -14,9 +14,7 @@
 #include <stan/math/rev/functor/integrate_dae.hpp>
 #include <stan/math/rev/functor/integrate_ode_adams.hpp>
 #include <stan/math/rev/functor/integrate_ode_bdf.hpp>
-#include <stan/math/rev/functor/ode_add_time_gradients.hpp>
 #include <stan/math/rev/functor/ode_bdf.hpp>
-#include <stan/math/rev/functor/ode_rk45.hpp>
 #include <stan/math/rev/functor/jacobian.hpp>
 #include <stan/math/rev/functor/kinsol_data.hpp>
 #include <stan/math/rev/functor/kinsol_solve.hpp>
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 74c9823f1ce..69ea26a6378 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -22,14 +22,15 @@ namespace math {
  *
  * @tparam Lmm ID of ODE solver (1: ADAMS, 2: BDF)
  */
-template <int Lmm, typename F, typename T_initial, typename... T_Args>
+template <int Lmm, typename F, typename T_initial, typename T_t0, typename T_ts, typename... T_Args>
 class cvodes_integrator {
-  using T_Return = return_type_t<T_initial, T_Args...>;
+  using T_Return = return_type_t<T_initial, T_t0, T_ts, T_Args...>;
+  using T_initial_or_t0 = return_type_t<T_initial, T_t0>;
 
   const F& f_;
-  const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_;
-  double t0_;
-  const std::vector<double>& ts_;
+  const Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1> y0_;
+  const T_t0 t0_;
+  const std::vector<T_ts>& ts_;
   std::tuple<const T_Args&...> args_tuple_;
   std::tuple<decltype(value_of(T_Args()))...> value_of_args_tuple_;
   const size_t N_;
@@ -41,7 +42,7 @@ class cvodes_integrator {
   const size_t y0_vars_;
   const size_t args_vars_;
 
-  coupled_ode_system<F, T_initial, T_Args...> coupled_ode_;
+  coupled_ode_system<F, T_initial_or_t0, T_Args...> coupled_ode_;
 
   Eigen::VectorXd coupled_state_;
   N_Vector nv_state_;
@@ -151,12 +152,12 @@ class cvodes_integrator {
 
  public:
   cvodes_integrator(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-		    double t0, const std::vector<double>& ts,
+		    const T_t0& t0, const std::vector<T_ts>& ts,
 		    double relative_tolerance, double absolute_tolerance,
 		    long int max_num_steps,
                     std::ostream* msgs, const T_Args&... args)
       : f_(f),
-        y0_(y0),
+	y0_(y0.unaryExpr([](const T_initial& val) { return T_initial_or_t0(val); })),
         t0_(t0),
         ts_(ts),
         args_tuple_(args...),
@@ -166,12 +167,10 @@ class cvodes_integrator {
         relative_tolerance_(relative_tolerance),
         absolute_tolerance_(absolute_tolerance),
         max_num_steps_(max_num_steps),
-        y0_vars_(count_vars(y0_)),
+	y0_vars_(count_vars(y0_)),
         args_vars_(count_vars(args...)),
-        coupled_ode_(f, y0, msgs, args...),
+        coupled_ode_(f, y0_, msgs, args...),
         coupled_state_(coupled_ode_.initial_state()) {
-    using initial_var = stan::is_var<T_initial>;
-
     const char* fun = "cvodes_integrator::integrate";
 
     check_finite(fun, "initial state", y0_);
@@ -321,7 +320,9 @@ class cvodes_integrator {
 
         y.emplace_back(apply(
             [&](auto&&... args) {
-              return ode_store_sensitivities(coupled_state_, y0_, args...);
+              return ode_store_sensitivities(f_, coupled_state_, y0_,
+					     t0_, ts_[n], msgs_,
+					     args...);
             },
             args_tuple_));
 
diff --git a/stan/math/rev/functor/ode_add_time_gradients.hpp b/stan/math/rev/functor/ode_add_time_gradients.hpp
deleted file mode 100644
index 2200e0f9abb..00000000000
--- a/stan/math/rev/functor/ode_add_time_gradients.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-#ifndef STAN_MATH_REV_FUNCTOR_ODE_ADD_TIME_GRADIENTS_HPP
-#define STAN_MATH_REV_FUNCTOR_ODE_ADD_TIME_GRADIENTS_HPP
-
-#include <stan/math/rev/meta.hpp>
-#include <stan/math/rev/core.hpp>
-#include <ostream>
-#include <vector>
-
-namespace stan {
-namespace math {
-namespace internal {
-inline double ode_time_gradient_var(double t, double grad) {
-  invalid_argument("ode_time_gradient_var", "t", t,
-                   "t must be of type var, not double");
-  return 0.0;
-}
-
-inline var ode_time_gradient_var(var t, double grad) {
-  return var(new precomp_v_vari(0.0, t.vi_, grad));
-}
-};  // namespace internal
-
-template <typename F, typename T_initial, typename T_out, typename... T_Args>
-inline auto ode_add_time_gradients(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-                            double t0, const std::vector<double>& ts,
-                            const std::vector<Eigen::Matrix<T_out, Eigen::Dynamic, 1>>& y,
-                            std::ostream* msgs, const T_Args&... args) {
-  return y;
-}
-
-template <typename F, typename T_initial, typename T_t0, typename T_ts,
-          typename T_out, typename... T_Args>
-std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>>
-ode_add_time_gradients(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-		       const T_t0& t0, const std::vector<T_ts>& ts,
-		       const std::vector<Eigen::Matrix<T_out, Eigen::Dynamic, 1>>& y,
-		       std::ostream* msgs, const T_Args&... args) {
-  Eigen::VectorXd f_y0_t0;
-  if (is_var<T_t0>::value) {
-    f_y0_t0 = f(value_of(t0), value_of(y0), msgs, value_of(args)...);
-
-    check_size_match("coupled_ode_observer", "dy_dt", f_y0_t0.size(), "states",
-                     y0.size());
-  }
-
-  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> y_with_gradients(y.size());
-
-  for (size_t i = 0; i < y.size(); ++i) {
-    Eigen::VectorXd f_y_t;
-
-    y_with_gradients[i].resize(y[i].size());
-
-    if (is_var<T_ts>::value)
-      f_y_t = f(value_of(ts[i]), value_of(y[i]), msgs, value_of(args)...);
-
-    for (size_t j = 0; j < y[i].size(); ++j) {
-      y_with_gradients[i](j) = y[i][j];
-
-      if (is_var<T_t0>::value)
-        y_with_gradients[i](j) += internal::ode_time_gradient_var(t0, -f_y0_t0[j]);
-
-      if (is_var<T_ts>::value)
-        y_with_gradients[i](j) += internal::ode_time_gradient_var(ts[i], f_y_t[j]);
-    }
-  }
-
-  return y_with_gradients;
-}
-
-}  // namespace math
-}  // namespace stan
-#endif
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 084c807fd27..32184000d26 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -2,7 +2,6 @@
 #define STAN_MATH_REV_FUNCTOR_ODE_BDF_HPP
 
 #include <stan/math/rev/meta.hpp>
-#include <stan/math/rev/functor/ode_add_time_gradients.hpp>
 #include <stan/math/rev/functor/cvodes_integrator.hpp>
 #include <ostream>
 #include <vector>
@@ -33,15 +32,11 @@ ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, c
             const std::vector<T_ts>& ts, double relative_tolerance,
             double absolute_tolerance, long int max_num_steps,
             std::ostream* msgs, const T_Args&... args) {
-  std::vector<double> value_of_ts = value_of(ts);
-
-  stan::math::cvodes_integrator<CV_BDF, F, T_initial, T_Args...> integrator(
-      f, y0, value_of(t0), value_of_ts, relative_tolerance, absolute_tolerance,
+  stan::math::cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
+      f, y0, t0, ts, relative_tolerance, absolute_tolerance,
       max_num_steps, msgs, args...);
 
-  auto y = integrator.integrate();
-  
-  return ode_add_time_gradients(f, y0, t0, ts, y, msgs, args...);
+  return integrator.integrate();
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/ode_rk45.hpp b/stan/math/rev/functor/ode_rk45.hpp
deleted file mode 100644
index 61120d99e21..00000000000
--- a/stan/math/rev/functor/ode_rk45.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#ifndef STAN_MATH_REV_FUNCTOR_ODE_RK45_HPP
-#define STAN_MATH_REV_FUNCTOR_ODE_RK45_HPP
-
-#include <stan/math/rev/meta.hpp>
-#include <stan/math/prim/functor/ode_rk45.hpp>
-#include <ostream>
-#include <vector>
-
-namespace stan {
-namespace math {
-
-template <typename F, typename T_initial, typename T_t0, typename T_ts,
-          typename... T_Args>
-std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>>
-ode_rk45(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, const T_t0& t0,
-	 const std::vector<T_ts>& ts, std::ostream* msgs, const T_Args&... args) {
-  double relative_tolerance = 1e-6;
-  double absolute_tolerance = 1e-6;
-  long int max_num_steps = 1e6;
-
-  return ode_rk45_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
-                      max_num_steps, msgs, args...);
-}
-
-template <typename F, typename T_initial, typename T_t0, typename T_ts,
-          typename... T_Args>
-std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>>
-ode_rk45_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, const T_t0& t0,
-	     const std::vector<T_ts>& ts, double relative_tolerance,
-	     double absolute_tolerance, long int max_num_steps, std::ostream* msgs,
-	     const T_Args&... args) {
-  auto y = ode_rk45_tol(f, y0, value_of(t0), value_of(ts), relative_tolerance,
-                        absolute_tolerance, max_num_steps, msgs, args...);
-
-  return ode_add_time_gradients(f, y0, t0, ts, y, msgs, args...);
-}
-
-}  // namespace math
-}  // namespace stan
-#endif
diff --git a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
index 11e6c356c11..ac36a76ee45 100644
--- a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
@@ -264,44 +264,41 @@ TEST(StanAgradRevOde_integrate_ode_bdf, t0_as_param_AD) {
   using stan::math::value_of;
   using stan::math::var;
   const double t0 = 0.0;
-  const int nt = 100;  // nb. of time steps
-  const int ns = 2;    // nb. of states
   std::ostream* msgs = NULL;
 
   harm_osc_ode_fun ode;
 
-  std::vector<double> theta{0.15, 0.25};
+  std::vector<double> theta{0.15};
   std::vector<double> y0{1.0, 0.0};
-  std::vector<double> ts;
-  for (int i = 0; i < nt; i++)
-    ts.push_back(t0 + 0.1 * (i + 1));
+  std::vector<double> ts = { 5.0, 10.0 };
 
   std::vector<double> x;
   std::vector<int> x_int;
   std::vector<stan::math::var> y0v = to_var(y0);
   std::vector<stan::math::var> thetav = to_var(theta);
-  stan::math::var t0v = 0.0;
+  stan::math::var t0v = to_var(t0);
 
   std::vector<std::vector<stan::math::var> > res;
-  auto test_ad = [&res, &t0v, &ode, &nt, &ns, &theta, &x, &x_int, &msgs]() {
-    for (auto i = 0; i < nt; ++i) {
-      std::vector<double> res_d = value_of(res[i]);
-      for (auto j = 0; j < ns; ++j) {
-        res[i][0].grad();
-        EXPECT_FLOAT_EQ(t0v.adj(), 0.0);
-        stan::math::set_zero_all_adjoints();
-        res[i][1].grad();
-        EXPECT_FLOAT_EQ(t0v.adj(), 1.0);
-        stan::math::set_zero_all_adjoints();
-      }
-    }
+  auto test_ad = [&res, &t0v, &ode, &theta, &x, &x_int, &msgs]() {
+    res[0][0].grad();
+    EXPECT_FLOAT_EQ(t0v.adj(), -0.66360742442816977871);
+    stan::math::set_zero_all_adjoints();
+    res[0][1].grad();
+    EXPECT_FLOAT_EQ(t0v.adj(), 0.23542843380353062344);
+    stan::math::set_zero_all_adjoints();
+    res[1][0].grad();
+    EXPECT_FLOAT_EQ(t0v.adj(), -0.2464078910913158893);
+    stan::math::set_zero_all_adjoints();
+    res[1][1].grad();
+    EXPECT_FLOAT_EQ(t0v.adj(), -0.38494826636037426937);
+    stan::math::set_zero_all_adjoints();
   };
-  res = integrate_ode_bdf(ode, y0, t0v, ts, theta, x, x_int);
+  res = integrate_ode_bdf(ode, y0, t0v, ts, theta, x, x_int, nullptr, 1e-10, 1e-10, 1e6);
   test_ad();
-  res = integrate_ode_bdf(ode, y0v, t0v, ts, theta, x, x_int);
+  res = integrate_ode_bdf(ode, y0v, t0v, ts, theta, x, x_int, nullptr, 1e-10, 1e-10, 1e6);
   test_ad();
-  res = integrate_ode_bdf(ode, y0, t0v, ts, thetav, x, x_int);
+  res = integrate_ode_bdf(ode, y0, t0v, ts, thetav, x, x_int, nullptr, 1e-10, 1e-10, 1e6);
   test_ad();
-  res = integrate_ode_bdf(ode, y0v, t0v, ts, thetav, x, x_int);
+  res = integrate_ode_bdf(ode, y0v, t0v, ts, thetav, x, x_int, nullptr, 1e-10, 1e-10, 1e6);
   test_ad();
 }
diff --git a/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
index 0be95f1c88c..d507292e6ec 100644
--- a/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
@@ -229,42 +229,41 @@ TEST(StanAgradRevOde_integrate_ode_rk45, t0_as_param_AD) {
   using stan::math::value_of;
   using stan::math::var;
   const double t0 = 0.0;
-  const int nt = 100;  // nb. of time steps
-  const int ns = 2;    // nb. of states
   std::ostream* msgs = NULL;
 
   harm_osc_ode_fun ode;
 
   std::vector<double> theta{0.15};
   std::vector<double> y0{1.0, 0.0};
-  std::vector<double> ts;
-  for (int i = 0; i < nt; i++)
-    ts.push_back(t0 + 0.1 * (i + 1));
+  std::vector<double> ts = { 5.0, 10.0 };
 
   std::vector<double> x;
   std::vector<int> x_int;
   std::vector<stan::math::var> y0v = to_var(y0);
   std::vector<stan::math::var> thetav = to_var(theta);
-  stan::math::var t0v = 0.0;
-
-  std::vector<std::vector<stan::math::var>> res;
-  auto test_ad = [&res, &t0v, &ode, &nt, &ns, &theta, &x, &x_int, &msgs]() {
-    for (auto i = 0; i < nt; ++i) {
-      std::vector<double> res_d = value_of(res[i]);
-      res[i][0].grad();
-      EXPECT_FLOAT_EQ(t0v.adj(), 0.0);
-      stan::math::set_zero_all_adjoints();
-      res[i][1].grad();
-      EXPECT_FLOAT_EQ(t0v.adj(), 1.0);
-      stan::math::set_zero_all_adjoints();
-    }
+  stan::math::var t0v = to_var(t0);
+
+  std::vector<std::vector<stan::math::var> > res;
+  auto test_ad = [&res, &t0v, &ode, &theta, &x, &x_int, &msgs]() {
+    res[0][0].grad();
+    EXPECT_FLOAT_EQ(t0v.adj(), -0.66360742442816977871);
+    stan::math::set_zero_all_adjoints();
+    res[0][1].grad();
+    EXPECT_FLOAT_EQ(t0v.adj(), 0.23542843380353062344);
+    stan::math::set_zero_all_adjoints();
+    res[1][0].grad();
+    EXPECT_FLOAT_EQ(t0v.adj(), -0.2464078910913158893);
+    stan::math::set_zero_all_adjoints();
+    res[1][1].grad();
+    EXPECT_FLOAT_EQ(t0v.adj(), -0.38494826636037426937);
+    stan::math::set_zero_all_adjoints();
   };
-  res = integrate_ode_rk45(ode, y0, t0v, ts, theta, x, x_int);
+  res = integrate_ode_rk45(ode, y0, t0v, ts, theta, x, x_int, nullptr, 1e-10, 1e-10, 1e6);
   test_ad();
-  res = integrate_ode_rk45(ode, y0v, t0v, ts, theta, x, x_int);
+  res = integrate_ode_rk45(ode, y0v, t0v, ts, theta, x, x_int, nullptr, 1e-10, 1e-10, 1e6);
   test_ad();
-  res = integrate_ode_rk45(ode, y0, t0v, ts, thetav, x, x_int);
+  res = integrate_ode_rk45(ode, y0, t0v, ts, thetav, x, x_int, nullptr, 1e-10, 1e-10, 1e6);
   test_ad();
-  res = integrate_ode_rk45(ode, y0v, t0v, ts, thetav, x, x_int);
+  res = integrate_ode_rk45(ode, y0v, t0v, ts, thetav, x, x_int, nullptr, 1e-10, 1e-10, 1e6);
   test_ad();
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
similarity index 56%
rename from test/unit/math/rev/functor/ode_bdf_prim_test.cpp
rename to test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index c59a954234e..0a252669f20 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -8,6 +8,8 @@
 #include <limits>
 #include <string>
 
+using stan::math::var;
+
 template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
 T sum_(T arg) {
   return arg;
@@ -221,3 +223,133 @@ struct ayt {
     return -a * y * t;
   }
 };
+
+void check_t0(const var& t0) {
+  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+}
+
+void check_t0(double t0) {}
+
+void check_ts(const std::vector<var>& ts) {
+  EXPECT_FLOAT_EQ(ts[0].adj(), 0.0);
+  EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
+}
+
+void check_ts(const std::vector<double>& ts) {}
+
+void check_y0(const Eigen::Matrix<var, Eigen::Dynamic, 1>& y0) {
+  EXPECT_FLOAT_EQ(y0(0).adj(), 0.5);
+}
+
+void check_y0(const Eigen::MatrixXd& y0) {}
+
+TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
+  var t0 = 0.5;
+  var a = 0.2;
+  std::vector<var> ts = { 1.25 };
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
+  y0 << 0.75;
+
+  double t0d = stan::math::value_of(t0);
+  double ad = stan::math::value_of(a);
+  std::vector<double> tsd = stan::math::value_of(ts);
+  Eigen::VectorXd y0d = stan::math::value_of(y0);
+
+  auto check_yT = [&](auto yT) {
+    EXPECT_FLOAT_EQ(stan::math::value_of(yT), y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_t0 = [&](var t0) {
+    EXPECT_FLOAT_EQ(t0.adj(), ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_a = [&](var a) {
+    EXPECT_FLOAT_EQ(a.adj(), -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_ts = [&](std::vector<var> ts) {
+    EXPECT_FLOAT_EQ(ts[0].adj(), -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
+    EXPECT_FLOAT_EQ(y0(0).adj(), exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+  
+  double yT1 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  check_yT(yT1);
+
+  var yT2 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT2.grad();
+  check_yT(yT2); check_a(a);
+
+  var yT3 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT3.grad();
+  check_yT(yT3); check_ts(ts);
+
+  var yT4 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT4.grad();
+  check_yT(yT4); check_ts(ts); check_a(a);
+
+  var yT5 = stan::math::ode_bdf_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT5.grad();
+  check_yT(yT5); check_t0(t0);
+
+  var yT6 = stan::math::ode_bdf_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT6.grad();
+  check_yT(yT6); check_t0(t0); check_a(a);
+
+  var yT7 = stan::math::ode_bdf_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT7.grad();
+  check_yT(yT7); check_t0(t0); check_ts(ts);
+
+  var yT8 = stan::math::ode_bdf_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT8.grad();
+  check_yT(yT8); check_t0(t0); check_ts(ts); check_a(a);
+
+  var yT9 = stan::math::ode_bdf_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT9.grad();
+  check_yT(yT9); check_y0(y0);
+
+  var yT10 = stan::math::ode_bdf_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT10.grad();
+  check_yT(yT10); check_y0(y0); check_a(a);
+
+  var yT11 = stan::math::ode_bdf_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT11.grad();
+  check_yT(yT11); check_y0(y0); check_ts(ts);
+
+  var yT12 = stan::math::ode_bdf_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT12.grad();
+  check_yT(yT12); check_y0(y0); check_ts(ts); check_a(a);
+
+  var yT13 = stan::math::ode_bdf_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT13.grad();
+  check_yT(yT13); check_y0(y0); check_t0(t0);
+
+  var yT14 = stan::math::ode_bdf_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT14.grad();
+  check_yT(yT14); check_y0(y0); check_t0(t0); check_a(a);
+
+  var yT15 = stan::math::ode_bdf_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT15.grad();
+  check_yT(yT15); check_y0(y0); check_t0(t0); check_ts(ts);
+
+  var yT16 = stan::math::ode_bdf_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT16.grad();
+  check_yT(yT16); check_y0(y0); check_t0(t0); check_ts(ts); check_a(a);
+}
diff --git a/test/unit/math/rev/functor/ode_rk45_prim_test.cpp b/test/unit/math/rev/functor/ode_rk45_prim_test.cpp
deleted file mode 100644
index be038285806..00000000000
--- a/test/unit/math/rev/functor/ode_rk45_prim_test.cpp
+++ /dev/null
@@ -1,210 +0,0 @@
-#include <stan/math/rev.hpp>
-#include <boost/numeric/odeint.hpp>
-#include <gtest/gtest.h>
-#include <test/unit/util.hpp>
-#include <iostream>
-#include <sstream>
-#include <vector>
-#include <limits>
-#include <string>
-
-template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
-T sum_(T arg) {
-  return arg;
-}
-
-template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
-auto sum_(EigMat&& arg) {
-  return stan::math::sum(arg);
-}
-
-template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
-auto sum_(Vec&& arg) {
-  stan::scalar_type_t<Vec> sum = 0;
-  for (size_t i = 0; i < arg.size(); ++i) {
-    sum += sum_(arg[i]);
-  }
-  return sum;
-}
-
-struct CosArg1 {
-  template <typename T0, typename T1, typename... T_Args>
-  inline std::vector<stan::return_type_t<T1, T_Args...>> operator()(
-      const T0& t, const std::vector<T1>& y, std::ostream* msgs,
-      const T_Args&... a) const {
-    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
-        = {sum_(a)...};
-    return {stan::math::cos(sum_(vec) * t)};
-  }
-};
-
-struct Cos2Arg {
-  template <typename T0, typename T1, typename T2, typename T3>
-  inline std::vector<typename stan::return_type<T1, T2, T3>::type> operator()(
-      const T0& t, const std::vector<T1>& y, std::ostream* msgs, const T2& a,
-      const T3& b) const {
-    return {stan::math::cos((sum_(a) + sum_(b)) * t)};
-  }
-};
-
-TEST(StanMathOde_ode_rk45_tol, t0) {
-  using stan::math::var;
-
-  std::vector<double> y0 = {0.0};
-  var t0 = 0.0;
-  std::vector<double> ts = {0.45, 1.1};
-
-  double a = 1.5;
-
-  std::vector<std::vector<var>> output = stan::math::ode_rk45_tol(
-      CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
-
-  output[0][0].grad();
-
-  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
-
-  stan::math::set_zero_all_adjoints();
-
-  output[1][0].grad();
-
-  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
-}
-
-TEST(StanMathOde_ode_rk45_tol, ts) {
-  using stan::math::var;
-
-  std::vector<double> y0 = {0.0};
-  double t0 = 0.0;
-  std::vector<var> ts = {0.45, 1.1};
-
-  double a = 1.5;
-
-  std::vector<std::vector<var>> output = stan::math::ode_rk45_tol(
-      CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
-
-  output[0][0].grad();
-
-  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
-
-  stan::math::set_zero_all_adjoints();
-
-  output[1][0].grad();
-
-  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
-}
-
-TEST(StanMathOde_ode_rk45_tol, scalar_arg) {
-  using stan::math::var;
-
-  std::vector<double> y0 = {0.0};
-  double t0 = 0.0;
-  std::vector<double> ts = {1.1};
-
-  var a = 1.5;
-
-  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0][0];
-
-  output.grad();
-
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
-}
-
-TEST(StanMathOde_ode_rk45_tol, std_vector_arg) {
-  using stan::math::var;
-
-  std::vector<double> y0 = {0.0};
-  double t0 = 0.0;
-  std::vector<double> ts = {1.1};
-
-  std::vector<var> a = {1.5};
-
-  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0][0];
-
-  output.grad();
-
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a[0].adj(), -0.50107310888);
-}
-
-TEST(StanMathOde_ode_rk45_tol, vector_arg) {
-  using stan::math::var;
-
-  std::vector<double> y0 = {0.0};
-  double t0 = 0.0;
-  std::vector<double> ts = {1.1};
-
-  Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
-  a << 1.5;
-
-  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0][0];
-
-  output.grad();
-
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
-}
-
-TEST(StanMathOde_ode_rk45_tol, row_vector_arg) {
-  using stan::math::var;
-
-  std::vector<double> y0 = {0.0};
-  double t0 = 0.0;
-  std::vector<double> ts = {1.1};
-
-  Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
-  a << 1.5;
-
-  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0][0];
-
-  output.grad();
-
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
-}
-
-TEST(StanMathOde_ode_rk45_tol, matrix_arg) {
-  using stan::math::var;
-
-  std::vector<double> y0 = {0.0};
-  double t0 = 0.0;
-  std::vector<double> ts = {1.1};
-
-  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
-  a << 1.5;
-
-  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0][0];
-
-  output.grad();
-
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a(0, 0).adj(), -0.50107310888);
-}
-
-TEST(StanMathOde_ode_rk45_tol, scalar_std_vector_args) {
-  using stan::math::var;
-
-  std::vector<double> y0 = {0.0};
-  double t0 = 0.0;
-  std::vector<double> ts = {1.1};
-
-  var a0 = 0.0;
-  std::vector<var> a1 = {1.5};
-
-  var output = stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a0, a1)[0][0];
-
-  output.grad();
-
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
-}
diff --git a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
new file mode 100644
index 00000000000..bf2cda3d1ea
--- /dev/null
+++ b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
@@ -0,0 +1,338 @@
+#include <stan/math/rev.hpp>
+#include <boost/numeric/odeint.hpp>
+#include <gtest/gtest.h>
+#include <test/unit/util.hpp>
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <limits>
+#include <string>
+
+using stan::math::var;
+
+template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
+T sum_(T arg) {
+  return arg;
+}
+
+template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
+auto sum_(EigMat&& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
+auto sum_(Vec&& arg) {
+  stan::scalar_type_t<Vec> sum = 0;
+  for (size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
+  }
+  return sum;
+}
+
+struct CosArg1 {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T0, T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+	     std::ostream* msgs,
+	     const T_Args&... a) const {
+    std::vector<typename stan::return_type<T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T0, T1, T_Args...>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos(sum_(vec) * t);
+    return out;
+  }
+};
+
+struct Cos2Arg {
+  template <typename T0, typename T1, typename T2, typename T3>
+  inline Eigen::Matrix<typename stan::return_type<T1, T2, T3>::type, Eigen::Dynamic, 1>
+  operator()(const T0& t,
+	     const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+	     std::ostream* msgs, const T2& a,
+	     const T3& b) const {
+    Eigen::Matrix<stan::return_type_t<T0, T1, T2, T3>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos((sum_(a) + sum_(b)) * t);
+    return out;
+  }
+};
+
+TEST(StanMathOde_ode_rk45_tol, t0) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  var t0 = 0.0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output = stan::math::ode_rk45_tol(
+      CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+}
+
+TEST(StanMathOde_ode_rk45_tol, ts) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<var> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output = stan::math::ode_rk45_tol(
+      CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, scalar_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a = 1.5;
+
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a)[0](0);
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, std_vector_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  std::vector<var> a = {1.5};
+
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a)[0](0);
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a[0].adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, vector_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
+  a << 1.5;
+
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a)[0](0);
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, row_vector_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
+  a << 1.5;
+
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a)[0](0);
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, matrix_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
+  a << 1.5;
+
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a)[0](0);
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0, 0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, scalar_std_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 0.0;
+  std::vector<var> a1 = {1.5};
+
+  var output = stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a0, a1)[0](0);
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
+}
+struct ayt {
+  template <typename T0, typename T1, typename T2>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1> operator()(
+	const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y, std::ostream* msgs,
+      const T2& a) const {
+    return -a * y * t;
+  }
+};
+
+TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
+  var t0 = 0.5;
+  var a = 0.2;
+  std::vector<var> ts = { 1.25 };
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
+  y0 << 0.75;
+
+  double t0d = stan::math::value_of(t0);
+  double ad = stan::math::value_of(a);
+  std::vector<double> tsd = stan::math::value_of(ts);
+  Eigen::VectorXd y0d = stan::math::value_of(y0);
+
+  auto check_yT = [&](auto yT) {
+    EXPECT_FLOAT_EQ(stan::math::value_of(yT), y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_t0 = [&](var t0) {
+    EXPECT_FLOAT_EQ(t0.adj(), ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_a = [&](var a) {
+    EXPECT_FLOAT_EQ(a.adj(), -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_ts = [&](std::vector<var> ts) {
+    EXPECT_FLOAT_EQ(ts[0].adj(), -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
+    EXPECT_FLOAT_EQ(y0(0).adj(), exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+  
+  double yT1 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  check_yT(yT1);
+
+  var yT2 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT2.grad();
+  check_yT(yT2); check_a(a);
+
+  var yT3 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT3.grad();
+  check_yT(yT3); check_ts(ts);
+
+  var yT4 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT4.grad();
+  check_yT(yT4); check_ts(ts); check_a(a);
+
+  var yT5 = stan::math::ode_rk45_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT5.grad();
+  check_yT(yT5); check_t0(t0);
+
+  var yT6 = stan::math::ode_rk45_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT6.grad();
+  check_yT(yT6); check_t0(t0); check_a(a);
+
+  var yT7 = stan::math::ode_rk45_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT7.grad();
+  check_yT(yT7); check_t0(t0); check_ts(ts);
+
+  var yT8 = stan::math::ode_rk45_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT8.grad();
+  check_yT(yT8); check_t0(t0); check_ts(ts); check_a(a);
+
+  var yT9 = stan::math::ode_rk45_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT9.grad();
+  check_yT(yT9); check_y0(y0);
+
+  var yT10 = stan::math::ode_rk45_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT10.grad();
+  check_yT(yT10); check_y0(y0); check_a(a);
+
+  var yT11 = stan::math::ode_rk45_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT11.grad();
+  check_yT(yT11); check_y0(y0); check_ts(ts);
+
+  var yT12 = stan::math::ode_rk45_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT12.grad();
+  check_yT(yT12); check_y0(y0); check_ts(ts); check_a(a);
+
+  var yT13 = stan::math::ode_rk45_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT13.grad();
+  check_yT(yT13); check_y0(y0); check_t0(t0);
+
+  var yT14 = stan::math::ode_rk45_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT14.grad();
+  check_yT(yT14); check_y0(y0); check_t0(t0); check_a(a);
+
+  var yT15 = stan::math::ode_rk45_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT15.grad();
+  check_yT(yT15); check_y0(y0); check_t0(t0); check_ts(ts);
+
+  var yT16 = stan::math::ode_rk45_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT16.grad();
+  check_yT(yT16); check_y0(y0); check_t0(t0); check_ts(ts); check_a(a);
+}

From e3e2b9eeefc1f6c2b48419a090443245c8f904d5 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Sat, 9 May 2020 21:13:18 +0000
Subject: [PATCH 110/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

---
 .../math/prim/fun/ode_store_sensitivities.hpp |  10 +-
 stan/math/prim/functor/coupled_ode_system.hpp |   3 +-
 stan/math/prim/functor/integrate_ode_rk45.hpp |   8 +-
 ...grate_ode_std_vector_interface_adapter.hpp |  16 +-
 stan/math/prim/functor/ode_rk45.hpp           |  46 ++---
 stan/math/rev/fun/ode_store_sensitivities.hpp |  29 ++-
 stan/math/rev/functor/coupled_ode_system.hpp  |  11 +-
 stan/math/rev/functor/cvodes_integrator.hpp   |  33 ++--
 stan/math/rev/functor/integrate_ode_bdf.hpp   |  11 +-
 stan/math/rev/functor/ode_bdf.hpp             |  26 +--
 .../functor/integrate_ode_bdf_rev_test.cpp    |  14 +-
 .../functor/integrate_ode_rk45_rev_test.cpp   |  16 +-
 .../math/rev/functor/ode_bdf_rev_test.cpp     | 164 +++++++++++------
 .../math/rev/functor/ode_rk45_rev_test.cpp    | 172 ++++++++++++------
 14 files changed, 341 insertions(+), 218 deletions(-)

diff --git a/stan/math/prim/fun/ode_store_sensitivities.hpp b/stan/math/prim/fun/ode_store_sensitivities.hpp
index 2025fc2fb34..d1a54851b9b 100644
--- a/stan/math/prim/fun/ode_store_sensitivities.hpp
+++ b/stan/math/prim/fun/ode_store_sensitivities.hpp
@@ -11,12 +11,10 @@ namespace math {
 template <typename F, typename... Args,
           typename = require_all_arithmetic_t<scalar_type_t<Args>...>>
 Eigen::VectorXd ode_store_sensitivities(const F& f,
-					const Eigen::VectorXd& coupled_state,
-					const Eigen::VectorXd& y0,
-					double t0,
-					double t,
-					std::ostream* msgs,
-					const Args&... args) {
+                                        const Eigen::VectorXd& coupled_state,
+                                        const Eigen::VectorXd& y0, double t0,
+                                        double t, std::ostream* msgs,
+                                        const Args&... args) {
   return coupled_state.head(y0.size());
 }
 
diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
index 6f3e76f2c1b..004dfb8009c 100644
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -129,7 +129,8 @@ struct coupled_ode_system
     : public coupled_ode_system_impl<
           std::is_arithmetic<return_type_t<T_initial, Args...>>::value, F,
           T_initial, Args...> {
-  coupled_ode_system(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+  coupled_ode_system(const F& f,
+                     const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
                      std::ostream* msgs, const Args&... args)
       : coupled_ode_system_impl<
             std::is_arithmetic<return_type_t<T_initial, Args...>>::value, F,
diff --git a/stan/math/prim/functor/integrate_ode_rk45.hpp b/stan/math/prim/functor/integrate_ode_rk45.hpp
index f478458081b..6313db5bf3b 100644
--- a/stan/math/prim/functor/integrate_ode_rk45.hpp
+++ b/stan/math/prim/functor/integrate_ode_rk45.hpp
@@ -68,12 +68,12 @@ integrate_ode_rk45(const F& f, const std::vector<T1>& y0, const T_t0& t0,
                    double relative_tolerance = 1e-6,
                    double absolute_tolerance = 1e-6, int max_num_steps = 1e6) {
   internal::integrate_ode_std_vector_interface_adapter<F> f_adapted(f);
-  auto y = ode_rk45_tol(f_adapted, to_vector(y0), t0, ts,
-			relative_tolerance, absolute_tolerance,
-			max_num_steps, msgs, theta, x, x_int);
+  auto y
+      = ode_rk45_tol(f_adapted, to_vector(y0), t0, ts, relative_tolerance,
+                     absolute_tolerance, max_num_steps, msgs, theta, x, x_int);
 
   std::vector<std::vector<return_type_t<T1, T_param, T_t0, T_ts>>> y_converted;
-  for(size_t i = 0; i < y.size(); ++i)
+  for (size_t i = 0; i < y.size(); ++i)
     y_converted.push_back(to_array_1d(y[i]));
 
   return y_converted;
diff --git a/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp b/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp
index ffeb30958f4..e2fdaf14605 100644
--- a/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp
+++ b/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp
@@ -17,18 +17,18 @@ struct integrate_ode_std_vector_interface_adapter {
   //  this function might go out of scope in reverse mode
   const F f_;
 
-  integrate_ode_std_vector_interface_adapter(const F& f) : f_(f) {
-  }
-  
-  template<typename T0, typename T1, typename T2>
-  auto operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y, std::ostream* msgs,
-		  const std::vector<T2>& theta, const std::vector<double>& x,
-		  const std::vector<int>& x_int) const {
+  integrate_ode_std_vector_interface_adapter(const F& f) : f_(f) {}
+
+  template <typename T0, typename T1, typename T2>
+  auto operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+                  std::ostream* msgs, const std::vector<T2>& theta,
+                  const std::vector<double>& x,
+                  const std::vector<int>& x_int) const {
     return to_vector(f_(t, to_array_1d(y), msgs, theta, x, x_int));
   }
 };
 
-}
+}  // namespace internal
 
 }  // namespace math
 }  // namespace stan
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index b220c15a372..aadb9763a7d 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -13,10 +13,11 @@ namespace stan {
 namespace math {
 
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
-	  typename... Args>
-std::vector<Eigen::Matrix<stan::return_type_t<T_initial, Args...>, Eigen::Dynamic, 1>>
-ode_rk45(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, double t0,
-         const std::vector<double>& ts, std::ostream* msgs,
+          typename... Args>
+std::vector<
+    Eigen::Matrix<stan::return_type_t<T_initial, Args...>, Eigen::Dynamic, 1>>
+ode_rk45(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+         double t0, const std::vector<double>& ts, std::ostream* msgs,
          const Args&... args) {
   double relative_tolerance = 1e-6;
   double absolute_tolerance = 1e-6;
@@ -27,10 +28,11 @@ ode_rk45(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, doub
 }
 
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
-	  typename... Args>
-std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, Args...>, Eigen::Dynamic, 1>>
-ode_rk45_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_arg,
-	     T_t0 t0,
+          typename... Args>
+std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, Args...>,
+                          Eigen::Dynamic, 1>>
+ode_rk45_tol(const F& f,
+             const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_arg, T_t0 t0,
              const std::vector<T_ts>& ts, double relative_tolerance,
              double absolute_tolerance, long int max_num_steps,
              std::ostream* msgs, const Args&... args) {
@@ -41,10 +43,9 @@ ode_rk45_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_a
   using boost::numeric::odeint::vector_space_algebra;
 
   using T_initial_or_t0 = return_type_t<T_initial, T_t0>;
-  
-  Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1> y0 = y0_arg.unaryExpr([](const T_initial& val) {
-      return T_initial_or_t0(val);
-    });
+
+  Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1> y0 = y0_arg.unaryExpr(
+      [](const T_initial& val) { return T_initial_or_t0(val); });
   const std::vector<double> ts_dbl = value_of(ts);
 
   check_finite("integrate_ode_rk45", "initial state", y0);
@@ -77,7 +78,7 @@ ode_rk45_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_a
   using return_t = return_type_t<T_initial, T_t0, T_ts, Args...>;
   // creates basic or coupled system by template specializations
   coupled_ode_system<F, T_initial_or_t0, Args...> coupled_system(f, y0, msgs,
-								 args...);
+                                                                 args...);
 
   // first time in the vector must be time of initial state
   std::vector<double> ts_vec(ts.size() + 1);
@@ -91,14 +92,13 @@ ode_rk45_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_a
   // avoid recording of the initial state which is included by the
   // conventions of odeint in the output
   auto filtered_observer
-    = [&](const Eigen::VectorXd& coupled_state, double t) -> void {
+      = [&](const Eigen::VectorXd& coupled_state, double t) -> void {
     if (!observer_initial_recorded) {
       observer_initial_recorded = true;
       return;
     }
-    y.emplace_back(ode_store_sensitivities(f, coupled_state, y0,
-					   t0, ts[time_index],
-					   msgs, args...));
+    y.emplace_back(ode_store_sensitivities(f, coupled_state, y0, t0,
+                                           ts[time_index], msgs, args...));
     time_index++;
   };
 
@@ -107,12 +107,12 @@ ode_rk45_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_a
 
   const double step_size = 0.1;
   integrate_times(
-      make_dense_output(absolute_tolerance, relative_tolerance,
-                        runge_kutta_dopri5<Eigen::VectorXd, double,
-			                   Eigen::VectorXd, double,
-			                   vector_space_algebra>()),
-      std::ref(coupled_system), initial_coupled_state,
-      std::begin(ts_vec), std::end(ts_vec), step_size, filtered_observer,
+      make_dense_output(
+          absolute_tolerance, relative_tolerance,
+          runge_kutta_dopri5<Eigen::VectorXd, double, Eigen::VectorXd, double,
+                             vector_space_algebra>()),
+      std::ref(coupled_system), initial_coupled_state, std::begin(ts_vec),
+      std::end(ts_vec), step_size, filtered_observer,
       max_step_checker(max_num_steps));
 
   return y;
diff --git a/stan/math/rev/fun/ode_store_sensitivities.hpp b/stan/math/rev/fun/ode_store_sensitivities.hpp
index d7ea8aa0f3a..04932fc51b0 100644
--- a/stan/math/rev/fun/ode_store_sensitivities.hpp
+++ b/stan/math/rev/fun/ode_store_sensitivities.hpp
@@ -9,14 +9,12 @@
 namespace stan {
 namespace math {
 
-template <typename F, typename T_initial_or_t0, typename T_t0, typename T_t, typename... Args>
-Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(const F& f,
-							      const Eigen::VectorXd& coupled_state,
-							      const Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1>& y0,
-							      const T_t0& t0,
-							      const T_t& t,
-							      std::ostream* msgs,
-							      const Args&... args) {
+template <typename F, typename T_initial_or_t0, typename T_t0, typename T_t,
+          typename... Args>
+Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
+    const F& f, const Eigen::VectorXd& coupled_state,
+    const Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1>& y0, const T_t0& t0,
+    const T_t& t, std::ostream* msgs, const Args&... args) {
   const size_t N = y0.size();
   const size_t y0_vars = count_vars(y0);
   const size_t args_vars = count_vars(args...);
@@ -25,7 +23,7 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(const F& f,
   Eigen::Matrix<var, Eigen::Dynamic, 1> yt(N);
 
   Eigen::VectorXd y = coupled_state.head(N);
-  
+
   Eigen::VectorXd f_y_t;
   if (is_var<T_t>::value)
     f_y_t = f(value_of(t), y, msgs, value_of(args)...);
@@ -62,25 +60,24 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(const F& f,
     }
 
     varis_ptr = save_varis(varis_ptr, t0);
-    if(t0_vars > 0) {
+    if (t0_vars > 0) {
       double dyt_dt0 = 0.0;
       for (std::size_t k = 0; k < y0_vars; ++k) {
-	// dy[j]_dtheta[k]
-	// theta[k].vi_
-	dyt_dt0 += -f_y0_t0[k] * coupled_state(N + y0_vars * k + j);
+        // dy[j]_dtheta[k]
+        // theta[k].vi_
+        dyt_dt0 += -f_y0_t0[k] * coupled_state(N + y0_vars * k + j);
       }
       *partials_ptr = dyt_dt0;
       partials_ptr++;
     }
 
     varis_ptr = save_varis(varis_ptr, t);
-    if(t_vars > 0) {
+    if (t_vars > 0) {
       *partials_ptr = f_y_t[j];
       partials_ptr++;
     }
 
-    yt(j) = new precomputed_gradients_vari(y(j), total_vars,
-					   varis, partials);
+    yt(j) = new precomputed_gradients_vari(y(j), total_vars, varis, partials);
   }
 
   return yt;
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index f46e333ebf9..32679eb9e0f 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -85,7 +85,8 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
    * @param[in] x_int integer data
    * @param[in, out] msgs stream for messages
    */
-  coupled_ode_system_impl(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+  coupled_ode_system_impl(const F& f,
+                          const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
                           std::ostream* msgs, const Args&... args)
       : f_(f),
         y0_(y0),
@@ -114,12 +115,12 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
     using std::vector;
 
     dz_dt.resize(size());
-    
+
     // Run nested autodiff in this scope
     nested_rev_autodiff nested;
 
     Eigen::Matrix<var, Eigen::Dynamic, 1> y_vars(N_);
-    for(size_t n = 0; n < N_; ++n)
+    for (size_t n = 0; n < N_; ++n)
       y_vars(n) = z(n);
 
     auto local_args_tuple = apply(
@@ -130,8 +131,8 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
         args_tuple_);
 
     Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars
-      = apply([&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
-	      local_args_tuple);
+        = apply([&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
+                local_args_tuple);
 
     check_size_match("coupled_ode_system", "dy_dt", f_y_t_vars.size(), "states",
                      N_);
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 69ea26a6378..575944d2f0e 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -22,7 +22,8 @@ namespace math {
  *
  * @tparam Lmm ID of ODE solver (1: ADAMS, 2: BDF)
  */
-template <int Lmm, typename F, typename T_initial, typename T_t0, typename T_ts, typename... T_Args>
+template <int Lmm, typename F, typename T_initial, typename T_t0, typename T_ts,
+          typename... T_Args>
 class cvodes_integrator {
   using T_Return = return_type_t<T_initial, T_t0, T_ts, T_Args...>;
   using T_initial_or_t0 = return_type_t<T_initial, T_t0>;
@@ -97,8 +98,8 @@ class cvodes_integrator {
     const Eigen::VectorXd y_vec = Eigen::Map<const Eigen::VectorXd>(y, N_);
 
     Eigen::VectorXd dy_dt_vec
-      = apply([&](auto&&... args) { return f_(t, y_vec, msgs_, args...); },
-	      value_of_args_tuple_);
+        = apply([&](auto&&... args) { return f_(t, y_vec, msgs_, args...); },
+                value_of_args_tuple_);
 
     check_size_match("cvodes_integrator::rhs", "dy_dt", dy_dt_vec.size(),
                      "states", N_);
@@ -116,7 +117,7 @@ class cvodes_integrator {
 
     auto f_wrapped = [&](const Eigen::Matrix<var, Eigen::Dynamic, 1>& y) {
       return apply([&](auto&&... args) { return f_(t, y, msgs_, args...); },
-          value_of_args_tuple_);
+                   value_of_args_tuple_);
     };
 
     jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(y, N_), fy, Jfy);
@@ -151,13 +152,15 @@ class cvodes_integrator {
   }
 
  public:
-  cvodes_integrator(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-		    const T_t0& t0, const std::vector<T_ts>& ts,
-		    double relative_tolerance, double absolute_tolerance,
-		    long int max_num_steps,
-                    std::ostream* msgs, const T_Args&... args)
+  cvodes_integrator(const F& f,
+                    const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+                    const T_t0& t0, const std::vector<T_ts>& ts,
+                    double relative_tolerance, double absolute_tolerance,
+                    long int max_num_steps, std::ostream* msgs,
+                    const T_Args&... args)
       : f_(f),
-	y0_(y0.unaryExpr([](const T_initial& val) { return T_initial_or_t0(val); })),
+        y0_(y0.unaryExpr(
+            [](const T_initial& val) { return T_initial_or_t0(val); })),
         t0_(t0),
         ts_(ts),
         args_tuple_(args...),
@@ -167,7 +170,7 @@ class cvodes_integrator {
         relative_tolerance_(relative_tolerance),
         absolute_tolerance_(absolute_tolerance),
         max_num_steps_(max_num_steps),
-	y0_vars_(count_vars(y0_)),
+        y0_vars_(count_vars(y0_)),
         args_vars_(count_vars(args...)),
         coupled_ode_(f, y0_, msgs, args...),
         coupled_state_(coupled_ode_.initial_state()) {
@@ -257,7 +260,8 @@ class cvodes_integrator {
    * @return a vector of states, each state being a vector of the
    * same size as the state variable, corresponding to a time in ts.
    */
-  std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> integrate() {  // NOLINT(runtime/int)
+  std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>>
+  integrate() {  // NOLINT(runtime/int)
     std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> y;
 
     const double t0_dbl = value_of(t0_);
@@ -320,9 +324,8 @@ class cvodes_integrator {
 
         y.emplace_back(apply(
             [&](auto&&... args) {
-              return ode_store_sensitivities(f_, coupled_state_, y0_,
-					     t0_, ts_[n], msgs_,
-					     args...);
+              return ode_store_sensitivities(f_, coupled_state_, y0_, t0_,
+                                             ts_[n], msgs_, args...);
             },
             args_tuple_));
 
diff --git a/stan/math/rev/functor/integrate_ode_bdf.hpp b/stan/math/rev/functor/integrate_ode_bdf.hpp
index 723fea0e700..d20666e748c 100644
--- a/stan/math/rev/functor/integrate_ode_bdf.hpp
+++ b/stan/math/rev/functor/integrate_ode_bdf.hpp
@@ -22,12 +22,13 @@ integrate_ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
                   double absolute_tolerance = 1e-10,
                   long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
   internal::integrate_ode_std_vector_interface_adapter<F> f_adapted(f);
-  auto y = ode_bdf_tol(f_adapted, to_vector(y0), t0, ts,
-		       relative_tolerance, absolute_tolerance,
-		       max_num_steps, msgs, theta, x, x_int);
+  auto y
+      = ode_bdf_tol(f_adapted, to_vector(y0), t0, ts, relative_tolerance,
+                    absolute_tolerance, max_num_steps, msgs, theta, x, x_int);
 
-  std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>> y_converted;
-  for(size_t i = 0; i < y.size(); ++i)
+  std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>>
+      y_converted;
+  for (size_t i = 0; i < y.size(); ++i)
     y_converted.push_back(to_array_1d(y[i]));
 
   return y_converted;
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 32184000d26..0e800a68107 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -11,10 +11,10 @@ namespace math {
 
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
-std::vector<Eigen::Matrix<
-	      stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>, Eigen::Dynamic, 1>>
-ode_bdf(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, const T_t0& t0,
-        const std::vector<T_ts>& ts, std::ostream* msgs,
+std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
+                          Eigen::Dynamic, 1>>
+ode_bdf(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+        const T_t0& t0, const std::vector<T_ts>& ts, std::ostream* msgs,
         const T_Args&... args) {
   double relative_tolerance = 1e-6;
   double absolute_tolerance = 1e-6;
@@ -26,15 +26,15 @@ ode_bdf(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, const
 
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
-std::vector<Eigen::Matrix<
-	      stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>, Eigen::Dynamic, 1>>
-ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, const T_t0& t0,
-            const std::vector<T_ts>& ts, double relative_tolerance,
-            double absolute_tolerance, long int max_num_steps,
-            std::ostream* msgs, const T_Args&... args) {
-  stan::math::cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
-      f, y0, t0, ts, relative_tolerance, absolute_tolerance,
-      max_num_steps, msgs, args...);
+std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
+                          Eigen::Dynamic, 1>>
+ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+            const T_t0& t0, const std::vector<T_ts>& ts,
+            double relative_tolerance, double absolute_tolerance,
+            long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
+  stan::math::cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...>
+  integrator(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
+             max_num_steps, msgs, args...);
 
   return integrator.integrate();
 }
diff --git a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
index ac36a76ee45..df8452b7b2c 100644
--- a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
@@ -270,7 +270,7 @@ TEST(StanAgradRevOde_integrate_ode_bdf, t0_as_param_AD) {
 
   std::vector<double> theta{0.15};
   std::vector<double> y0{1.0, 0.0};
-  std::vector<double> ts = { 5.0, 10.0 };
+  std::vector<double> ts = {5.0, 10.0};
 
   std::vector<double> x;
   std::vector<int> x_int;
@@ -293,12 +293,16 @@ TEST(StanAgradRevOde_integrate_ode_bdf, t0_as_param_AD) {
     EXPECT_FLOAT_EQ(t0v.adj(), -0.38494826636037426937);
     stan::math::set_zero_all_adjoints();
   };
-  res = integrate_ode_bdf(ode, y0, t0v, ts, theta, x, x_int, nullptr, 1e-10, 1e-10, 1e6);
+  res = integrate_ode_bdf(ode, y0, t0v, ts, theta, x, x_int, nullptr, 1e-10,
+                          1e-10, 1e6);
   test_ad();
-  res = integrate_ode_bdf(ode, y0v, t0v, ts, theta, x, x_int, nullptr, 1e-10, 1e-10, 1e6);
+  res = integrate_ode_bdf(ode, y0v, t0v, ts, theta, x, x_int, nullptr, 1e-10,
+                          1e-10, 1e6);
   test_ad();
-  res = integrate_ode_bdf(ode, y0, t0v, ts, thetav, x, x_int, nullptr, 1e-10, 1e-10, 1e6);
+  res = integrate_ode_bdf(ode, y0, t0v, ts, thetav, x, x_int, nullptr, 1e-10,
+                          1e-10, 1e6);
   test_ad();
-  res = integrate_ode_bdf(ode, y0v, t0v, ts, thetav, x, x_int, nullptr, 1e-10, 1e-10, 1e6);
+  res = integrate_ode_bdf(ode, y0v, t0v, ts, thetav, x, x_int, nullptr, 1e-10,
+                          1e-10, 1e6);
   test_ad();
 }
diff --git a/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
index d507292e6ec..f64006d140e 100644
--- a/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
@@ -235,7 +235,7 @@ TEST(StanAgradRevOde_integrate_ode_rk45, t0_as_param_AD) {
 
   std::vector<double> theta{0.15};
   std::vector<double> y0{1.0, 0.0};
-  std::vector<double> ts = { 5.0, 10.0 };
+  std::vector<double> ts = {5.0, 10.0};
 
   std::vector<double> x;
   std::vector<int> x_int;
@@ -243,7 +243,7 @@ TEST(StanAgradRevOde_integrate_ode_rk45, t0_as_param_AD) {
   std::vector<stan::math::var> thetav = to_var(theta);
   stan::math::var t0v = to_var(t0);
 
-  std::vector<std::vector<stan::math::var> > res;
+  std::vector<std::vector<stan::math::var>> res;
   auto test_ad = [&res, &t0v, &ode, &theta, &x, &x_int, &msgs]() {
     res[0][0].grad();
     EXPECT_FLOAT_EQ(t0v.adj(), -0.66360742442816977871);
@@ -258,12 +258,16 @@ TEST(StanAgradRevOde_integrate_ode_rk45, t0_as_param_AD) {
     EXPECT_FLOAT_EQ(t0v.adj(), -0.38494826636037426937);
     stan::math::set_zero_all_adjoints();
   };
-  res = integrate_ode_rk45(ode, y0, t0v, ts, theta, x, x_int, nullptr, 1e-10, 1e-10, 1e6);
+  res = integrate_ode_rk45(ode, y0, t0v, ts, theta, x, x_int, nullptr, 1e-10,
+                           1e-10, 1e6);
   test_ad();
-  res = integrate_ode_rk45(ode, y0v, t0v, ts, theta, x, x_int, nullptr, 1e-10, 1e-10, 1e6);
+  res = integrate_ode_rk45(ode, y0v, t0v, ts, theta, x, x_int, nullptr, 1e-10,
+                           1e-10, 1e6);
   test_ad();
-  res = integrate_ode_rk45(ode, y0, t0v, ts, thetav, x, x_int, nullptr, 1e-10, 1e-10, 1e6);
+  res = integrate_ode_rk45(ode, y0, t0v, ts, thetav, x, x_int, nullptr, 1e-10,
+                           1e-10, 1e6);
   test_ad();
-  res = integrate_ode_rk45(ode, y0v, t0v, ts, thetav, x, x_int, nullptr, 1e-10, 1e-10, 1e6);
+  res = integrate_ode_rk45(ode, y0v, t0v, ts, thetav, x, x_int, nullptr, 1e-10,
+                           1e-10, 1e6);
   test_ad();
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index 0a252669f20..1165a58e82e 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -31,9 +31,9 @@ auto sum_(Vec&& arg) {
 
 struct CosArg1 {
   template <typename T0, typename T1, typename... T_Args>
-  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> operator()(
-											 const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y, std::ostream* msgs,
-      const T_Args&... a) const {
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
     std::vector<typename stan::return_type<T0, T_Args...>::type> vec
         = {sum_(a)...};
     Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(1);
@@ -44,9 +44,9 @@ struct CosArg1 {
 
 struct Cos2Arg {
   template <typename T0, typename T1, typename T2, typename T3>
-  inline Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1> operator()(
-										      const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y, std::ostream* msgs, const T2& a,
-      const T3& b) const {
+  inline Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a, const T3& b) const {
     Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1> out(1);
     out << stan::math::cos((sum_(a) + sum_(b)) * t);
     return out;
@@ -62,8 +62,9 @@ TEST(StanMathOde_ode_bdf_tol, t0) {
 
   double a = 1.5;
 
-  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output = stan::math::ode_bdf_tol(
-      CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
 
   output[0][0].grad();
 
@@ -87,8 +88,9 @@ TEST(StanMathOde_ode_bdf_tol, ts) {
 
   double a = 1.5;
 
-  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output = stan::math::ode_bdf_tol(
-      CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
 
   output[0][0].grad();
 
@@ -217,16 +219,14 @@ TEST(StanMathOde_ode_bdf_tol, scalar_std_vector_args) {
 
 struct ayt {
   template <typename T0, typename T1, typename T2>
-  inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1> operator()(
-	const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y, std::ostream* msgs,
-      const T2& a) const {
+  inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a) const {
     return -a * y * t;
   }
 };
 
-void check_t0(const var& t0) {
-  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
-}
+void check_t0(const var& t0) { EXPECT_FLOAT_EQ(t0.adj(), -1.0); }
 
 void check_t0(double t0) {}
 
@@ -246,7 +246,7 @@ void check_y0(const Eigen::MatrixXd& y0) {}
 TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   var t0 = 0.5;
   var a = 0.2;
-  std::vector<var> ts = { 1.25 };
+  std::vector<var> ts = {1.25};
   Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
   y0 << 0.75;
 
@@ -256,100 +256,156 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   Eigen::VectorXd y0d = stan::math::value_of(y0);
 
   auto check_yT = [&](auto yT) {
-    EXPECT_FLOAT_EQ(stan::math::value_of(yT), y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
   auto check_t0 = [&](var t0) {
-    EXPECT_FLOAT_EQ(t0.adj(), ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+    EXPECT_FLOAT_EQ(
+        t0.adj(),
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
   auto check_a = [&](var a) {
-    EXPECT_FLOAT_EQ(a.adj(), -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+    EXPECT_FLOAT_EQ(a.adj(),
+                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
   auto check_ts = [&](std::vector<var> ts) {
-    EXPECT_FLOAT_EQ(ts[0].adj(), -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+    EXPECT_FLOAT_EQ(
+        ts[0].adj(),
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
   auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
-    EXPECT_FLOAT_EQ(y0(0).adj(), exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+    EXPECT_FLOAT_EQ(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
-  
-  double yT1 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+
+  double yT1 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                       nullptr, ad)[0](0);
   check_yT(yT1);
 
-  var yT2 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  var yT2 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
-  check_yT(yT2); check_a(a);
+  check_yT(yT2);
+  check_a(a);
 
-  var yT3 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  var yT3 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
-  check_yT(yT3); check_ts(ts);
+  check_yT(yT3);
+  check_ts(ts);
 
-  var yT4 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  var yT4 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
-  check_yT(yT4); check_ts(ts); check_a(a);
+  check_yT(yT4);
+  check_ts(ts);
+  check_a(a);
 
-  var yT5 = stan::math::ode_bdf_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  var yT5 = stan::math::ode_bdf_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
-  check_yT(yT5); check_t0(t0);
+  check_yT(yT5);
+  check_t0(t0);
 
-  var yT6 = stan::math::ode_bdf_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  var yT6 = stan::math::ode_bdf_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
-  check_yT(yT6); check_t0(t0); check_a(a);
+  check_yT(yT6);
+  check_t0(t0);
+  check_a(a);
 
-  var yT7 = stan::math::ode_bdf_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  var yT7 = stan::math::ode_bdf_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
-  check_yT(yT7); check_t0(t0); check_ts(ts);
+  check_yT(yT7);
+  check_t0(t0);
+  check_ts(ts);
 
-  var yT8 = stan::math::ode_bdf_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  var yT8 = stan::math::ode_bdf_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
-  check_yT(yT8); check_t0(t0); check_ts(ts); check_a(a);
+  check_yT(yT8);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
 
-  var yT9 = stan::math::ode_bdf_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  var yT9 = stan::math::ode_bdf_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
-  check_yT(yT9); check_y0(y0);
+  check_yT(yT9);
+  check_y0(y0);
 
-  var yT10 = stan::math::ode_bdf_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  var yT10 = stan::math::ode_bdf_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
-  check_yT(yT10); check_y0(y0); check_a(a);
+  check_yT(yT10);
+  check_y0(y0);
+  check_a(a);
 
-  var yT11 = stan::math::ode_bdf_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  var yT11 = stan::math::ode_bdf_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
-  check_yT(yT11); check_y0(y0); check_ts(ts);
+  check_yT(yT11);
+  check_y0(y0);
+  check_ts(ts);
 
-  var yT12 = stan::math::ode_bdf_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  var yT12 = stan::math::ode_bdf_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
-  check_yT(yT12); check_y0(y0); check_ts(ts); check_a(a);
+  check_yT(yT12);
+  check_y0(y0);
+  check_ts(ts);
+  check_a(a);
 
-  var yT13 = stan::math::ode_bdf_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  var yT13 = stan::math::ode_bdf_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
-  check_yT(yT13); check_y0(y0); check_t0(t0);
+  check_yT(yT13);
+  check_y0(y0);
+  check_t0(t0);
 
-  var yT14 = stan::math::ode_bdf_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  var yT14 = stan::math::ode_bdf_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
-  check_yT(yT14); check_y0(y0); check_t0(t0); check_a(a);
+  check_yT(yT14);
+  check_y0(y0);
+  check_t0(t0);
+  check_a(a);
 
-  var yT15 = stan::math::ode_bdf_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  var yT15 = stan::math::ode_bdf_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
-  check_yT(yT15); check_y0(y0); check_t0(t0); check_ts(ts);
+  check_yT(yT15);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
 
-  var yT16 = stan::math::ode_bdf_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  var yT16 = stan::math::ode_bdf_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
-  check_yT(yT16); check_y0(y0); check_t0(t0); check_ts(ts); check_a(a);
+  check_yT(yT16);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
 }
diff --git a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
index bf2cda3d1ea..daefbcbb19a 100644
--- a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
@@ -31,13 +31,13 @@ auto sum_(Vec&& arg) {
 
 struct CosArg1 {
   template <typename T0, typename T1, typename... T_Args>
-  inline Eigen::Matrix<stan::return_type_t<T0, T1, T_Args...>, Eigen::Dynamic, 1>
+  inline Eigen::Matrix<stan::return_type_t<T0, T1, T_Args...>, Eigen::Dynamic,
+                       1>
   operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
-	     std::ostream* msgs,
-	     const T_Args&... a) const {
-    std::vector<typename stan::return_type<T_Args...>::type> vec
-        = {sum_(a)...};
-    Eigen::Matrix<stan::return_type_t<T0, T1, T_Args...>, Eigen::Dynamic, 1> out(1);
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T_Args...>::type> vec = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T0, T1, T_Args...>, Eigen::Dynamic, 1>
+        out(1);
     out << stan::math::cos(sum_(vec) * t);
     return out;
   }
@@ -45,12 +45,12 @@ struct CosArg1 {
 
 struct Cos2Arg {
   template <typename T0, typename T1, typename T2, typename T3>
-  inline Eigen::Matrix<typename stan::return_type<T1, T2, T3>::type, Eigen::Dynamic, 1>
-  operator()(const T0& t,
-	     const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
-	     std::ostream* msgs, const T2& a,
-	     const T3& b) const {
-    Eigen::Matrix<stan::return_type_t<T0, T1, T2, T3>, Eigen::Dynamic, 1> out(1);
+  inline Eigen::Matrix<typename stan::return_type<T1, T2, T3>::type,
+                       Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a, const T3& b) const {
+    Eigen::Matrix<stan::return_type_t<T0, T1, T2, T3>, Eigen::Dynamic, 1> out(
+        1);
     out << stan::math::cos((sum_(a) + sum_(b)) * t);
     return out;
   }
@@ -65,8 +65,9 @@ TEST(StanMathOde_ode_rk45_tol, t0) {
 
   double a = 1.5;
 
-  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output = stan::math::ode_rk45_tol(
-      CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                 nullptr, a);
 
   output[0][0].grad();
 
@@ -90,8 +91,9 @@ TEST(StanMathOde_ode_rk45_tol, ts) {
 
   double a = 1.5;
 
-  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output = stan::math::ode_rk45_tol(
-      CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a);
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                 nullptr, a);
 
   output[0][0].grad();
 
@@ -219,9 +221,9 @@ TEST(StanMathOde_ode_rk45_tol, scalar_std_vector_args) {
 }
 struct ayt {
   template <typename T0, typename T1, typename T2>
-  inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1> operator()(
-	const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y, std::ostream* msgs,
-      const T2& a) const {
+  inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a) const {
     return -a * y * t;
   }
 };
@@ -229,7 +231,7 @@ struct ayt {
 TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   var t0 = 0.5;
   var a = 0.2;
-  std::vector<var> ts = { 1.25 };
+  std::vector<var> ts = {1.25};
   Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
   y0 << 0.75;
 
@@ -239,100 +241,156 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   Eigen::VectorXd y0d = stan::math::value_of(y0);
 
   auto check_yT = [&](auto yT) {
-    EXPECT_FLOAT_EQ(stan::math::value_of(yT), y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
   auto check_t0 = [&](var t0) {
-    EXPECT_FLOAT_EQ(t0.adj(), ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+    EXPECT_FLOAT_EQ(
+        t0.adj(),
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
   auto check_a = [&](var a) {
-    EXPECT_FLOAT_EQ(a.adj(), -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+    EXPECT_FLOAT_EQ(a.adj(),
+                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
   auto check_ts = [&](std::vector<var> ts) {
-    EXPECT_FLOAT_EQ(ts[0].adj(), -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+    EXPECT_FLOAT_EQ(
+        ts[0].adj(),
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
   auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
-    EXPECT_FLOAT_EQ(y0(0).adj(), exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+    EXPECT_FLOAT_EQ(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
-  
-  double yT1 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+
+  double yT1 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                        nullptr, ad)[0](0);
   check_yT(yT1);
 
-  var yT2 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  var yT2 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
-  check_yT(yT2); check_a(a);
+  check_yT(yT2);
+  check_a(a);
 
-  var yT3 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  var yT3 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
-  check_yT(yT3); check_ts(ts);
+  check_yT(yT3);
+  check_ts(ts);
 
-  var yT4 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  var yT4 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
-  check_yT(yT4); check_ts(ts); check_a(a);
+  check_yT(yT4);
+  check_ts(ts);
+  check_a(a);
 
-  var yT5 = stan::math::ode_rk45_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  var yT5 = stan::math::ode_rk45_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
-  check_yT(yT5); check_t0(t0);
+  check_yT(yT5);
+  check_t0(t0);
 
-  var yT6 = stan::math::ode_rk45_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  var yT6 = stan::math::ode_rk45_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
-  check_yT(yT6); check_t0(t0); check_a(a);
+  check_yT(yT6);
+  check_t0(t0);
+  check_a(a);
 
-  var yT7 = stan::math::ode_rk45_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  var yT7 = stan::math::ode_rk45_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
-  check_yT(yT7); check_t0(t0); check_ts(ts);
+  check_yT(yT7);
+  check_t0(t0);
+  check_ts(ts);
 
-  var yT8 = stan::math::ode_rk45_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  var yT8 = stan::math::ode_rk45_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
-  check_yT(yT8); check_t0(t0); check_ts(ts); check_a(a);
+  check_yT(yT8);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
 
-  var yT9 = stan::math::ode_rk45_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  var yT9 = stan::math::ode_rk45_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
-  check_yT(yT9); check_y0(y0);
+  check_yT(yT9);
+  check_y0(y0);
 
-  var yT10 = stan::math::ode_rk45_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  var yT10 = stan::math::ode_rk45_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
-  check_yT(yT10); check_y0(y0); check_a(a);
+  check_yT(yT10);
+  check_y0(y0);
+  check_a(a);
 
-  var yT11 = stan::math::ode_rk45_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  var yT11 = stan::math::ode_rk45_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
-  check_yT(yT11); check_y0(y0); check_ts(ts);
+  check_yT(yT11);
+  check_y0(y0);
+  check_ts(ts);
 
-  var yT12 = stan::math::ode_rk45_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  var yT12 = stan::math::ode_rk45_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
-  check_yT(yT12); check_y0(y0); check_ts(ts); check_a(a);
+  check_yT(yT12);
+  check_y0(y0);
+  check_ts(ts);
+  check_a(a);
 
-  var yT13 = stan::math::ode_rk45_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  var yT13 = stan::math::ode_rk45_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
-  check_yT(yT13); check_y0(y0); check_t0(t0);
+  check_yT(yT13);
+  check_y0(y0);
+  check_t0(t0);
 
-  var yT14 = stan::math::ode_rk45_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  var yT14 = stan::math::ode_rk45_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
-  check_yT(yT14); check_y0(y0); check_t0(t0); check_a(a);
+  check_yT(yT14);
+  check_y0(y0);
+  check_t0(t0);
+  check_a(a);
 
-  var yT15 = stan::math::ode_rk45_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, ad)[0](0);
+  var yT15 = stan::math::ode_rk45_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
-  check_yT(yT15); check_y0(y0); check_t0(t0); check_ts(ts);
+  check_yT(yT15);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
 
-  var yT16 = stan::math::ode_rk45_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6, nullptr, a)[0](0);
+  var yT16 = stan::math::ode_rk45_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
-  check_yT(yT16); check_y0(y0); check_t0(t0); check_ts(ts); check_a(a);
+  check_yT(yT16);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
 }

From 8bf8b8791fdf30b72cd605ac441c3c9a3030283e Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 11 May 2020 13:34:35 -0400
Subject: [PATCH 111/189] Updated ODE function docs

---
 stan/math/prim/fun.hpp                        |  1 -
 .../math/prim/fun/ode_store_sensitivities.hpp | 25 ------
 stan/math/prim/functor.hpp                    |  1 +
 stan/math/prim/functor/integrate_ode_rk45.hpp | 46 +---------
 ...grate_ode_std_vector_interface_adapter.hpp | 10 ++-
 stan/math/prim/functor/ode_rk45.hpp           | 87 +++++++++++++++++--
 .../prim/functor/ode_store_sensitivities.hpp  | 40 +++++++++
 stan/math/rev/functor.hpp                     |  1 +
 stan/math/rev/functor/cvodes_integrator.hpp   | 82 ++++++++---------
 stan/math/rev/functor/integrate_ode_bdf.hpp   |  3 +
 stan/math/rev/functor/ode_bdf.hpp             | 73 +++++++++++++++-
 .../ode_store_sensitivities.hpp               | 29 ++++++-
 12 files changed, 268 insertions(+), 130 deletions(-)
 delete mode 100644 stan/math/prim/fun/ode_store_sensitivities.hpp
 create mode 100644 stan/math/prim/functor/ode_store_sensitivities.hpp
 rename stan/math/rev/{fun => functor}/ode_store_sensitivities.hpp (68%)

diff --git a/stan/math/prim/fun.hpp b/stan/math/prim/fun.hpp
index d052d05da93..64dbb661311 100644
--- a/stan/math/prim/fun.hpp
+++ b/stan/math/prim/fun.hpp
@@ -213,7 +213,6 @@
 #include <stan/math/prim/fun/multiply_lower_tri_self_transpose.hpp>
 #include <stan/math/prim/fun/norm.hpp>
 #include <stan/math/prim/fun/num_elements.hpp>
-#include <stan/math/prim/fun/ode_store_sensitivities.hpp>
 #include <stan/math/prim/fun/offset_multiplier_constrain.hpp>
 #include <stan/math/prim/fun/offset_multiplier_free.hpp>
 #include <stan/math/prim/fun/one_hot_array.hpp>
diff --git a/stan/math/prim/fun/ode_store_sensitivities.hpp b/stan/math/prim/fun/ode_store_sensitivities.hpp
deleted file mode 100644
index 2025fc2fb34..00000000000
--- a/stan/math/prim/fun/ode_store_sensitivities.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#ifndef STAN_MATH_PRIM_FUN_ODE_STORE_SENSITIVITIES_HPP
-#define STAN_MATH_PRIM_FUN_ODE_STORE_SENSITIVITIES_HPP
-
-#include <stan/math/prim/meta.hpp>
-#include <ostream>
-#include <vector>
-
-namespace stan {
-namespace math {
-
-template <typename F, typename... Args,
-          typename = require_all_arithmetic_t<scalar_type_t<Args>...>>
-Eigen::VectorXd ode_store_sensitivities(const F& f,
-					const Eigen::VectorXd& coupled_state,
-					const Eigen::VectorXd& y0,
-					double t0,
-					double t,
-					std::ostream* msgs,
-					const Args&... args) {
-  return coupled_state.head(y0.size());
-}
-
-}  // namespace math
-}  // namespace stan
-#endif
diff --git a/stan/math/prim/functor.hpp b/stan/math/prim/functor.hpp
index 13dc85abe05..c7839d4670d 100644
--- a/stan/math/prim/functor.hpp
+++ b/stan/math/prim/functor.hpp
@@ -12,6 +12,7 @@
 #include <stan/math/prim/functor/integrate_ode_rk45.hpp>
 #include <stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp>
 #include <stan/math/prim/functor/ode_rk45.hpp>
+#include <stan/math/prim/functor/ode_store_sensitivities.hpp>
 #include <stan/math/prim/functor/map_rect.hpp>
 #include <stan/math/prim/functor/map_rect_combine.hpp>
 #include <stan/math/prim/functor/map_rect_concurrent.hpp>
diff --git a/stan/math/prim/functor/integrate_ode_rk45.hpp b/stan/math/prim/functor/integrate_ode_rk45.hpp
index f478458081b..3ba871e7ccf 100644
--- a/stan/math/prim/functor/integrate_ode_rk45.hpp
+++ b/stan/math/prim/functor/integrate_ode_rk45.hpp
@@ -11,52 +11,8 @@ namespace stan {
 namespace math {
 
 /**
- * Return the solutions for the specified system of ordinary
- * differential equations given the specified initial state,
- * initial times, times of desired solution, and parameters and
- * data, writing error and warning messages to the specified
- * stream.
- *
- * <b>Warning:</b> If the system of equations is stiff, roughly
- * defined by having varying time scales across dimensions, then
- * this solver is likely to be slow.
- *
- * This function is templated to allow the initial times to be
- * either data or autodiff variables and the parameters to be data
- * or autodiff variables.  The autodiff-based implementation for
- * reverse-mode are defined in namespace <code>stan::math</code>
- * and may be invoked via argument-dependent lookup by including
- * their headers.
- *
- * This function uses the <a
- * href="http://en.wikipedia.org/wiki/Dormand–Prince_method">Dormand-Prince
- * method</a> as implemented in Boost's <code>
- * boost::numeric::odeint::runge_kutta_dopri5</code> integrator.
- *
- * @tparam F type of ODE system function.
- * @tparam T1 type of scalars for initial values.
- * @tparam T2 type of scalars for parameters.
- * @tparam T_t0 type of scalar of initial time point.
- * @tparam T_ts type of time-points where ODE solution is returned.
- * @param[in] f functor for the base ordinary differential equation.
- * @param[in] y0 initial state.
- * @param[in] t0 initial time.
- * @param[in] ts times of the desired solutions, in strictly
- * increasing order, all greater than the initial time.
- * @param[in] theta parameter vector for the ODE.
- * @param[in] x continuous data vector for the ODE.
- * @param[in] x_int integer data vector for the ODE.
- * @param[out] msgs the print stream for warning messages.
- * @param[in] relative_tolerance relative tolerance parameter
- *   for Boost's ode solver. Defaults to 1e-6.
- * @param[in] absolute_tolerance absolute tolerance parameter
- *   for Boost's ode solver. Defaults to 1e-6.
- * @param[in] max_num_steps maximum number of steps to take within
- *   the Boost ode solver.
- * @return a vector of states, each state being a vector of the
- * same size as the state variable, corresponding to a time in ts.
+ * @deprecated use <code>ode_rk45</code>
  */
-
 template <typename F, typename T1, typename T_param, typename T_t0,
           typename T_ts>
 std::vector<std::vector<return_type_t<T1, T_t0, T_ts, T_param>>>
diff --git a/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp b/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp
index ffeb30958f4..a8d749a86d8 100644
--- a/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp
+++ b/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp
@@ -11,10 +11,16 @@ namespace math {
 
 namespace internal {
 
+/**
+ * Wrap a functor designed for use with integrate_ode_bdf, integrate_ode_rk45,
+ * and integrate_ode_adams to use with the new ode_bdf/ode_rk45 interfaces.
+ *
+ * The old functors took the ODE state as a std::vector. The new ones take
+ * state as an Eigen::Matrix. The adapter converts to and from these forms
+ * so that the old ODE interfaces can work.
+ */
 template <typename F>
 struct integrate_ode_std_vector_interface_adapter {
-  // NOTE: I made this copy by value because
-  //  this function might go out of scope in reverse mode
   const F f_;
 
   integrate_ode_std_vector_interface_adapter(const F& f) : f_(f) {
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index b220c15a372..b27f8bdcc2f 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -3,7 +3,7 @@
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/functor/coupled_ode_system.hpp>
-#include <stan/math/prim/fun/ode_store_sensitivities.hpp>
+#include <stan/math/prim/functor/ode_store_sensitivities.hpp>
 #include <boost/numeric/odeint/external/eigen/eigen_algebra.hpp>
 #include <boost/numeric/odeint.hpp>
 #include <ostream>
@@ -12,20 +12,94 @@
 namespace stan {
 namespace math {
 
+/**
+ * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
+ * times, { t1, t2, t3, ... } using the non-stiff Runge-Kutta 45 solver in Boost
+ * with a relative tolerance of 1e-10, an absolute tolerance of 1e-10, and
+ * taking a maximum of 1e8 steps.
+ *
+ * If the system of equations is stiff, <code>ode_bdf</code> will likely be
+ * faster.
+ *
+ * \p f must define an operator() with the signature as:
+ *   template<typename T_t, typename T_y, typename... T_Args>
+ *   Eigen::Matrix<stan::return_type_t<T_t, T_y, T_Args...>, Eigen::Dynamic, 1>
+ *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
+ *     std::ostream* msgs, const T_Args&... args);
+ *
+ * t is the time, y is the state, msgs is a stream for error messages, and args
+ * are optional arguments passed to the ODE solve function (which are passed
+ * through to \p f without modification).
+ *
+ * @tparam F Type of ODE right hand side
+ * @tparam T_0 Type of initial time
+ * @tparam T_ts Type of output times
+ * @tparam T_Args Types of pass-through parameters
+ *
+ * @param f Right hand side of the ODE
+ * @param y0 Initial state
+ * @param t0 Initial time
+ * @param ts Times at which to solve the ODE at. All values must be sorted and
+ *   not less than t0.
+ * @param relative_tolerance Relative tolerance passed to CVODES
+ * @param absolute_tolerance Absolute tolerance passed to CVODES
+ * @param max_num_steps Upper limit on the number of integration steps to
+ *   take between each output (error if exceeded)
+ * @param[in, out] msgs the print stream for warning messages
+ * @param args Extra arguments passed unmodified through to ODE right hand side
+ * @return Solution to ODE at times \p ts
+ */
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
 	  typename... Args>
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, Args...>, Eigen::Dynamic, 1>>
 ode_rk45(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, double t0,
          const std::vector<double>& ts, std::ostream* msgs,
          const Args&... args) {
-  double relative_tolerance = 1e-6;
-  double absolute_tolerance = 1e-6;
-  long int max_num_steps = 1e6;
+  double relative_tolerance = 1e-10;
+  double absolute_tolerance = 1e-10;
+  long int max_num_steps = 1e8;
 
   return ode_rk45_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
                       max_num_steps, msgs, args...);
 }
 
+/**
+ * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
+ * times, { t1, t2, t3, ... } using the non-stiff Runge-Kutta 45 solver in Boost
+ * with a relative tolerance of 1e-10, an absolute tolerance of 1e-10, and
+ * taking a maximum of 1e8 steps.
+ *
+ * If the system of equations is stiff, <code>ode_bdf</code> will likely be
+ * faster.
+ *
+ * \p f must define an operator() with the signature as:
+ *   template<typename T_t, typename T_y, typename... T_Args>
+ *   Eigen::Matrix<stan::return_type_t<T_t, T_y, T_Args...>, Eigen::Dynamic, 1>
+ *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
+ *     std::ostream* msgs, const T_Args&... args);
+ *
+ * t is the time, y is the state, msgs is a stream for error messages, and args
+ * are optional arguments passed to the ODE solve function (which are passed
+ * through to \p f without modification).
+ *
+ * @tparam F Type of ODE right hand side
+ * @tparam T_0 Type of initial time
+ * @tparam T_ts Type of output times
+ * @tparam T_Args Types of pass-through parameters
+ *
+ * @param f Right hand side of the ODE
+ * @param y0 Initial state
+ * @param t0 Initial time
+ * @param ts Times at which to solve the ODE at. All values must be sorted and
+ *   not less than t0.
+ * @param relative_tolerance Relative tolerance passed to CVODES
+ * @param absolute_tolerance Absolute tolerance passed to CVODES
+ * @param max_num_steps Upper limit on the number of integration steps to
+ *   take between each output (error if exceeded)
+ * @param[in, out] msgs the print stream for warning messages
+ * @param args Extra arguments passed unmodified through to ODE right hand side
+ * @return Solution to ODE at times \p ts
+ */
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
 	  typename... Args>
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, Args...>, Eigen::Dynamic, 1>>
@@ -88,6 +162,8 @@ ode_rk45_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_a
   bool observer_initial_recorded = false;
   size_t time_index = 0;
 
+  max_step_checker step_checker(max_num_steps);
+  
   // avoid recording of the initial state which is included by the
   // conventions of odeint in the output
   auto filtered_observer
@@ -99,6 +175,7 @@ ode_rk45_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_a
     y.emplace_back(ode_store_sensitivities(f, coupled_state, y0,
 					   t0, ts[time_index],
 					   msgs, args...));
+    step_checker.reset();
     time_index++;
   };
 
@@ -113,7 +190,7 @@ ode_rk45_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_a
 			                   vector_space_algebra>()),
       std::ref(coupled_system), initial_coupled_state,
       std::begin(ts_vec), std::end(ts_vec), step_size, filtered_observer,
-      max_step_checker(max_num_steps));
+      step_checker);
 
   return y;
 }
diff --git a/stan/math/prim/functor/ode_store_sensitivities.hpp b/stan/math/prim/functor/ode_store_sensitivities.hpp
new file mode 100644
index 00000000000..54a5b680dab
--- /dev/null
+++ b/stan/math/prim/functor/ode_store_sensitivities.hpp
@@ -0,0 +1,40 @@
+#ifndef STAN_MATH_PRIM_FUNCTOR_ODE_STORE_SENSITIVITIES_HPP
+#define STAN_MATH_PRIM_FUNCTOR_ODE_STORE_SENSITIVITIES_HPP
+
+#include <stan/math/prim/meta.hpp>
+#include <ostream>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+/**
+ * Build output for state of ODE solve from the current coupled_state when
+ * all arguments are arithmetic.
+ * 
+ * @tparam F Type of ODE right hand side
+ *
+ * @param f Right hand side of the ODE
+ * @param coupled_state Current state of the coupled_ode_system
+ * @param y0 Initial state
+ * @param t0 Initial time
+ * @param ts Times at which to solve the ODE at
+ * @param[in, out] msgs the print stream for warning messages
+ * @param args Extra arguments passed unmodified through to ODE right hand side
+ * @return ODE state
+ */
+template <typename F, typename... Args,
+          typename = require_all_arithmetic_t<scalar_type_t<Args>...>>
+Eigen::VectorXd ode_store_sensitivities(const F& f,
+					const Eigen::VectorXd& coupled_state,
+					const Eigen::VectorXd& y0,
+					double t0,
+					double t,
+					std::ostream* msgs,
+					const Args&... args) {
+  return coupled_state.head(y0.size());
+}
+
+}  // namespace math
+}  // namespace stan
+#endif
diff --git a/stan/math/rev/functor.hpp b/stan/math/rev/functor.hpp
index d1f31aef725..171036c0bd2 100644
--- a/stan/math/rev/functor.hpp
+++ b/stan/math/rev/functor.hpp
@@ -15,6 +15,7 @@
 #include <stan/math/rev/functor/integrate_ode_adams.hpp>
 #include <stan/math/rev/functor/integrate_ode_bdf.hpp>
 #include <stan/math/rev/functor/ode_bdf.hpp>
+#include <stan/math/rev/functor/ode_store_sensitivities.hpp>
 #include <stan/math/rev/functor/jacobian.hpp>
 #include <stan/math/rev/functor/kinsol_data.hpp>
 #include <stan/math/rev/functor/kinsol_solve.hpp>
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 69ea26a6378..53b42d75981 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -4,7 +4,7 @@
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/functor/cvodes_utils.hpp>
 #include <stan/math/rev/functor/coupled_ode_system.hpp>
-#include <stan/math/rev/fun/ode_store_sensitivities.hpp>
+#include <stan/math/rev/functor/ode_store_sensitivities.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/value_of.hpp>
 #include <cvodes/cvodes.h>
@@ -21,14 +21,19 @@ namespace math {
  * methods).
  *
  * @tparam Lmm ID of ODE solver (1: ADAMS, 2: BDF)
+ * @tparam F Type of ODE right hand side
+ * @tparam T_y0 Type of scalars for initial state
+ * @tparam T_param Type of scalars for parameters
+ * @tparam T_t0 Type of scalar of initial time point
+ * @tparam T_ts Type of time-points where ODE solution is returned
  */
-template <int Lmm, typename F, typename T_initial, typename T_t0, typename T_ts, typename... T_Args>
+template <int Lmm, typename F, typename T_y0, typename T_t0, typename T_ts, typename... T_Args>
 class cvodes_integrator {
-  using T_Return = return_type_t<T_initial, T_t0, T_ts, T_Args...>;
-  using T_initial_or_t0 = return_type_t<T_initial, T_t0>;
+  using T_Return = return_type_t<T_y0, T_t0, T_ts, T_Args...>;
+  using T_y0_t0 = return_type_t<T_y0, T_t0>;
 
   const F& f_;
-  const Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1> y0_;
+  const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1> y0_;
   const T_t0 t0_;
   const std::vector<T_ts>& ts_;
   std::tuple<const T_Args&...> args_tuple_;
@@ -42,7 +47,7 @@ class cvodes_integrator {
   const size_t y0_vars_;
   const size_t args_vars_;
 
-  coupled_ode_system<F, T_initial_or_t0, T_Args...> coupled_ode_;
+  coupled_ode_system<F, T_y0_t0, T_Args...> coupled_ode_;
 
   Eigen::VectorXd coupled_state_;
   N_Vector nv_state_;
@@ -151,13 +156,32 @@ class cvodes_integrator {
   }
 
  public:
-  cvodes_integrator(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+  /**
+   * Construct cvodes_integrator object
+   *
+   * @param f Right hand side of the ODE
+   * @param y0 Initial state
+   * @param t0 Initial time
+   * @param ts Times at which to solve the ODE at. All values must be sorted and
+   *   not less than t0.
+   * @param relative_tolerance Relative tolerance passed to CVODES
+   * @param absolute_tolerance Absolute tolerance passed to CVODES
+   * @param max_num_steps Upper limit on the number of integration steps to
+   *   take between each output (error if exceeded)
+   * @param[in, out] msgs the print stream for warning messages
+   * @param args Extra arguments passed unmodified through to ODE right hand side
+   *   function
+   * @return Solution to ODE at times \p ts
+   * @return a vector of states, each state being a vector of the
+   * same size as the state variable, corresponding to a time in ts.
+   */
+  cvodes_integrator(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
 		    const T_t0& t0, const std::vector<T_ts>& ts,
 		    double relative_tolerance, double absolute_tolerance,
 		    long int max_num_steps,
                     std::ostream* msgs, const T_Args&... args)
       : f_(f),
-	y0_(y0.unaryExpr([](const T_initial& val) { return T_initial_or_t0(val); })),
+	y0_(y0.unaryExpr([](const T_y0& val) { return T_y0_t0(val); })),
         t0_(t0),
         ts_(ts),
         args_tuple_(args...),
@@ -218,44 +242,12 @@ class cvodes_integrator {
   }
 
   /**
-   * Return the solutions for the specified system of ordinary
-   * differential equations given the specified initial state,
-   * initial times, times of desired solution, and parameters and
-   * data, writing error and warning messages to the specified
-   * stream.
+   * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
+   * times, { t1, t2, t3, ... } using the stiff backward differentiation formula
+   * (BDF) solver in CVODES.
    *
-   * This function is templated to allow the initials to be
-   * either data or autodiff variables and the parameters to be data
-   * or autodiff variables.  The autodiff-based implementation for
-   * reverse-mode are defined in namespace <code>stan::math</code>
-   * and may be invoked via argument-dependent lookup by including
-   * their headers.
-   *
-   * The solver used is based on the backward differentiation
-   * formula which is an implicit numerical integration scheme
-   * appropriate for stiff ODE systems.
-   *
-   * @tparam F type of ODE system function.
-   * @tparam T_initial type of scalars for initial values.
-   * @tparam T_param type of scalars for parameters.
-   * @tparam T_t0 type of scalar of initial time point.
-   * @tparam T_ts type of time-points where ODE solution is returned.
-   *
-   * @param[in] f functor for the base ordinary differential equation.
-   * @param[in] y0 initial state.
-   * @param[in] t0 initial time.
-   * @param[in] ts times of the desired solutions, in strictly
-   * increasing order, all greater than the initial time.
-   * @param[in] theta parameter vector for the ODE.
-   * @param[in] x continuous data vector for the ODE.
-   * @param[in] x_int integer data vector for the ODE.
-   * @param[in, out] msgs the print stream for warning messages.
-   * @param[in] relative_tolerance relative tolerance passed to CVODE.
-   * @param[in] absolute_tolerance absolute tolerance passed to CVODE.
-   * @param[in] max_num_steps maximal number of admissable steps
-   * between time-points
-   * @return a vector of states, each state being a vector of the
-   * same size as the state variable, corresponding to a time in ts.
+   * @return std::vector of Eigen::Matrix of the states of the ODE, one for each
+   *   solution time (excluding the initial state)
    */
   std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> integrate() {  // NOLINT(runtime/int)
     std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> y;
diff --git a/stan/math/rev/functor/integrate_ode_bdf.hpp b/stan/math/rev/functor/integrate_ode_bdf.hpp
index 723fea0e700..7a343e8ef80 100644
--- a/stan/math/rev/functor/integrate_ode_bdf.hpp
+++ b/stan/math/rev/functor/integrate_ode_bdf.hpp
@@ -10,6 +10,9 @@
 namespace stan {
 namespace math {
 
+/**
+ *  @deprecated use <code>ode_bdf</code>
+ */
 template <typename F, typename T_initial, typename T_param, typename T_t0,
           typename T_ts>
 std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>>
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 32184000d26..1c228a6bd05 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -9,6 +9,40 @@
 namespace stan {
 namespace math {
 
+/**
+ * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
+ * times, { t1, t2, t3, ... } using the stiff backward differentiation formula
+ * (BDF) solver in CVODES with a relative tolerance of 1e-10, an absolute
+ * tolerance of 1e-10, and taking a maximum of 1e8 steps.
+ *
+ * \p f must define an operator() with the signature as:
+ *   template<typename T_t, typename T_y, typename... T_Args>
+ *   Eigen::Matrix<stan::return_type_t<T_t, T_y, T_Args...>, Eigen::Dynamic, 1>
+ *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
+ *     std::ostream* msgs, const T_Args&... args);
+ *
+ * t is the time, y is the state, msgs is a stream for error messages, and args
+ * are optional arguments passed to the ODE solve function (which are passed
+ * through to \p f without modification).
+ *
+ * @tparam F Type of ODE right hand side
+ * @tparam T_0 Type of initial time
+ * @tparam T_ts Type of output times
+ * @tparam T_Args Types of pass-through parameters
+ *
+ * @param f Right hand side of the ODE
+ * @param y0 Initial state
+ * @param t0 Initial time
+ * @param ts Times at which to solve the ODE at. All values must be sorted and
+ *   not less than t0.
+ * @param relative_tolerance Relative tolerance passed to CVODES
+ * @param absolute_tolerance Absolute tolerance passed to CVODES
+ * @param max_num_steps Upper limit on the number of integration steps to
+ *   take between each output (error if exceeded)
+ * @param[in, out] msgs the print stream for warning messages
+ * @param args Extra arguments passed unmodified through to ODE right hand side
+ * @return Solution to ODE at times \p ts
+ */
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
 std::vector<Eigen::Matrix<
@@ -16,14 +50,47 @@ std::vector<Eigen::Matrix<
 ode_bdf(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0, const T_t0& t0,
         const std::vector<T_ts>& ts, std::ostream* msgs,
         const T_Args&... args) {
-  double relative_tolerance = 1e-6;
-  double absolute_tolerance = 1e-6;
-  long int max_num_steps = 1e6;
+  double relative_tolerance = 1e-10;
+  double absolute_tolerance = 1e-10;
+  long int max_num_steps = 1e8;
 
   return ode_bdf_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
                      max_num_steps, msgs, args...);
 }
 
+/**
+ * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
+ * times, { t1, t2, t3, ... } using the stiff backward differentiation formula
+ * BDF solver from CVODES.
+ *
+ * \p f must define an operator() with the signature as:
+ *   template<typename T_t, typename T_y, typename... T_Args>
+ *   Eigen::Matrix<stan::return_type_t<T_t, T_y, T_Args...>, Eigen::Dynamic, 1>
+ *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
+ *     std::ostream* msgs, const T_Args&... args);
+ *
+ * t is the time, y is the state, msgs is a stream for error messages, and args
+ * are optional arguments passed to the ODE solve function (which are passed
+ * through to \p f without modification).
+ *
+ * @tparam F Type of ODE right hand side
+ * @tparam T_0 Type of initial time
+ * @tparam T_ts Type of output times
+ * @tparam T_Args Types of pass-through parameters
+ *
+ * @param f Right hand side of the ODE
+ * @param y0 Initial state
+ * @param t0 Initial time
+ * @param ts Times at which to solve the ODE at. All values must be sorted and
+ *   not less than t0.
+ * @param relative_tolerance Relative tolerance passed to CVODES
+ * @param absolute_tolerance Absolute tolerance passed to CVODES
+ * @param max_num_steps Upper limit on the number of integration steps to
+ *   take between each output (error if exceeded)
+ * @param[in, out] msgs the print stream for warning messages
+ * @param args Extra arguments passed unmodified through to ODE right hand side
+ * @return Solution to ODE at times \p ts
+ */
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
 std::vector<Eigen::Matrix<
diff --git a/stan/math/rev/fun/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
similarity index 68%
rename from stan/math/rev/fun/ode_store_sensitivities.hpp
rename to stan/math/rev/functor/ode_store_sensitivities.hpp
index d7ea8aa0f3a..5a478d976ec 100644
--- a/stan/math/rev/fun/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -1,5 +1,5 @@
-#ifndef STAN_MATH_REV_FUN_ODE_STORE_SENSITIVITIES_HPP
-#define STAN_MATH_REV_FUN_ODE_STORE_SENSITIVITIES_HPP
+#ifndef STAN_MATH_REV_FUNCTOR_ODE_STORE_SENSITIVITIES_HPP
+#define STAN_MATH_REV_FUNCTOR_ODE_STORE_SENSITIVITIES_HPP
 
 #include <stan/math/prim/fun/ode_store_sensitivities.hpp>
 #include <stan/math/rev/core.hpp>
@@ -9,10 +9,31 @@
 namespace stan {
 namespace math {
 
-template <typename F, typename T_initial_or_t0, typename T_t0, typename T_t, typename... Args>
+/**
+ * Build output vars for a state of the ODE solve, storing the sensitivities
+ * precomputed using the forward sensitivity problem in precomputed varis.
+ *
+ * Any combination of y0, t0, ts, and any of the args arguments can have the
+ * var scalar type.
+ *
+ * @tparam F Type of ODE right hand side
+ * @tparam T_0 Type of initial time
+ * @tparam T_ts Type of output times
+ * @tparam T_Args Types of pass-through parameters
+ *
+ * @param f Right hand side of the ODE
+ * @param coupled_state Current state of the coupled_ode_system
+ * @param y0 Initial state
+ * @param t0 Initial time
+ * @param ts Times at which to solve the ODE at
+ * @param[in, out] msgs the print stream for warning messages
+ * @param args Extra arguments passed unmodified through to ODE right hand side
+ * @return ODE state with scalar type var
+ */
+template <typename F, typename T_y0_t0, typename T_t0, typename T_t, typename... Args>
 Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(const F& f,
 							      const Eigen::VectorXd& coupled_state,
-							      const Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1>& y0,
+							      const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0,
 							      const T_t0& t0,
 							      const T_t& t,
 							      std::ostream* msgs,

From cb602adc434e0d73caaa27eebcb32b893b0e05cd Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 11 May 2020 17:44:17 -0400
Subject: [PATCH 112/189] Updated ode_store_sensitivities references
 (design-doc #19)

---
 stan/math/rev/fun.hpp                             | 1 -
 stan/math/rev/functor/ode_store_sensitivities.hpp | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/stan/math/rev/fun.hpp b/stan/math/rev/fun.hpp
index 55bd2288e48..bc91d532da5 100644
--- a/stan/math/rev/fun.hpp
+++ b/stan/math/rev/fun.hpp
@@ -106,7 +106,6 @@
 #include <stan/math/rev/fun/multiply_log.hpp>
 #include <stan/math/rev/fun/multiply_lower_tri_self_transpose.hpp>
 #include <stan/math/rev/fun/norm.hpp>
-#include <stan/math/rev/fun/ode_store_sensitivities.hpp>
 #include <stan/math/rev/fun/ordered_constrain.hpp>
 #include <stan/math/rev/fun/owens_t.hpp>
 #include <stan/math/rev/fun/polar.hpp>
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index a70b47c67eb..fbf0a09b776 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -1,7 +1,7 @@
 #ifndef STAN_MATH_REV_FUNCTOR_ODE_STORE_SENSITIVITIES_HPP
 #define STAN_MATH_REV_FUNCTOR_ODE_STORE_SENSITIVITIES_HPP
 
-#include <stan/math/prim/fun/ode_store_sensitivities.hpp>
+#include <stan/math/prim/functor/ode_store_sensitivities.hpp>
 #include <stan/math/rev/core.hpp>
 #include <ostream>
 #include <vector>

From 983163435e4d8967323c9cf8f199a7fb643f9cd3 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 11 May 2020 21:48:27 +0000
Subject: [PATCH 113/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

---
 stan/math/prim/functor/ode_rk45.hpp           | 20 +++++++++----------
 .../prim/functor/ode_store_sensitivities.hpp  | 12 +++++------
 stan/math/rev/functor/cvodes_integrator.hpp   | 20 ++++++++++---------
 .../rev/functor/ode_store_sensitivities.hpp   | 14 ++++++-------
 4 files changed, 31 insertions(+), 35 deletions(-)

diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index e05667512e8..5d5fd2e9e81 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -164,7 +164,7 @@ ode_rk45_tol(const F& f,
   size_t time_index = 0;
 
   max_step_checker step_checker(max_num_steps);
-  
+
   // avoid recording of the initial state which is included by the
   // conventions of odeint in the output
   auto filtered_observer
@@ -173,9 +173,8 @@ ode_rk45_tol(const F& f,
       observer_initial_recorded = true;
       return;
     }
-    y.emplace_back(ode_store_sensitivities(f, coupled_state, y0,
-					   t0, ts[time_index],
-					   msgs, args...));
+    y.emplace_back(ode_store_sensitivities(f, coupled_state, y0, t0,
+                                           ts[time_index], msgs, args...));
     step_checker.reset();
     time_index++;
   };
@@ -185,13 +184,12 @@ ode_rk45_tol(const F& f,
 
   const double step_size = 0.1;
   integrate_times(
-      make_dense_output(absolute_tolerance, relative_tolerance,
-                        runge_kutta_dopri5<Eigen::VectorXd, double,
-			                   Eigen::VectorXd, double,
-			                   vector_space_algebra>()),
-      std::ref(coupled_system), initial_coupled_state,
-      std::begin(ts_vec), std::end(ts_vec), step_size, filtered_observer,
-      step_checker);
+      make_dense_output(
+          absolute_tolerance, relative_tolerance,
+          runge_kutta_dopri5<Eigen::VectorXd, double, Eigen::VectorXd, double,
+                             vector_space_algebra>()),
+      std::ref(coupled_system), initial_coupled_state, std::begin(ts_vec),
+      std::end(ts_vec), step_size, filtered_observer, step_checker);
 
   return y;
 }
diff --git a/stan/math/prim/functor/ode_store_sensitivities.hpp b/stan/math/prim/functor/ode_store_sensitivities.hpp
index 54a5b680dab..acf0fd61992 100644
--- a/stan/math/prim/functor/ode_store_sensitivities.hpp
+++ b/stan/math/prim/functor/ode_store_sensitivities.hpp
@@ -11,7 +11,7 @@ namespace math {
 /**
  * Build output for state of ODE solve from the current coupled_state when
  * all arguments are arithmetic.
- * 
+ *
  * @tparam F Type of ODE right hand side
  *
  * @param f Right hand side of the ODE
@@ -26,12 +26,10 @@ namespace math {
 template <typename F, typename... Args,
           typename = require_all_arithmetic_t<scalar_type_t<Args>...>>
 Eigen::VectorXd ode_store_sensitivities(const F& f,
-					const Eigen::VectorXd& coupled_state,
-					const Eigen::VectorXd& y0,
-					double t0,
-					double t,
-					std::ostream* msgs,
-					const Args&... args) {
+                                        const Eigen::VectorXd& coupled_state,
+                                        const Eigen::VectorXd& y0, double t0,
+                                        double t, std::ostream* msgs,
+                                        const Args&... args) {
   return coupled_state.head(y0.size());
 }
 
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index ff74bc4dfc7..10a6e3d059a 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -27,7 +27,8 @@ namespace math {
  * @tparam T_t0 Type of scalar of initial time point
  * @tparam T_ts Type of time-points where ODE solution is returned
  */
-template <int Lmm, typename F, typename T_y0, typename T_t0, typename T_ts, typename... T_Args>
+template <int Lmm, typename F, typename T_y0, typename T_t0, typename T_ts,
+          typename... T_Args>
 class cvodes_integrator {
   using T_Return = return_type_t<T_y0, T_t0, T_ts, T_Args...>;
   using T_y0_t0 = return_type_t<T_y0, T_t0>;
@@ -169,19 +170,20 @@ class cvodes_integrator {
    * @param max_num_steps Upper limit on the number of integration steps to
    *   take between each output (error if exceeded)
    * @param[in, out] msgs the print stream for warning messages
-   * @param args Extra arguments passed unmodified through to ODE right hand side
-   *   function
+   * @param args Extra arguments passed unmodified through to ODE right hand
+   * side function
    * @return Solution to ODE at times \p ts
    * @return a vector of states, each state being a vector of the
    * same size as the state variable, corresponding to a time in ts.
    */
-  cvodes_integrator(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
-		    const T_t0& t0, const std::vector<T_ts>& ts,
-		    double relative_tolerance, double absolute_tolerance,
-		    long int max_num_steps,
-                    std::ostream* msgs, const T_Args&... args)
+  cvodes_integrator(const F& f,
+                    const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
+                    const T_t0& t0, const std::vector<T_ts>& ts,
+                    double relative_tolerance, double absolute_tolerance,
+                    long int max_num_steps, std::ostream* msgs,
+                    const T_Args&... args)
       : f_(f),
-	y0_(y0.unaryExpr([](const T_y0& val) { return T_y0_t0(val); })),
+        y0_(y0.unaryExpr([](const T_y0& val) { return T_y0_t0(val); })),
         t0_(t0),
         ts_(ts),
         args_tuple_(args...),
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index fbf0a09b776..f2c505ccf08 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -30,14 +30,12 @@ namespace math {
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return ODE state with scalar type var
  */
-template <typename F, typename T_y0_t0, typename T_t0, typename T_t, typename... Args>
-Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(const F& f,
-							      const Eigen::VectorXd& coupled_state,
-							      const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0,
-							      const T_t0& t0,
-							      const T_t& t,
-							      std::ostream* msgs,
-							      const Args&... args) {
+template <typename F, typename T_y0_t0, typename T_t0, typename T_t,
+          typename... Args>
+Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
+    const F& f, const Eigen::VectorXd& coupled_state,
+    const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0, const T_t0& t0,
+    const T_t& t, std::ostream* msgs, const Args&... args) {
   const size_t N = y0.size();
   const size_t y0_vars = count_vars(y0);
   const size_t args_vars = count_vars(args...);

From 44529fd6c2a1fe46ef00ceef3d104c40e534b1d8 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Fri, 15 May 2020 20:05:16 -0400
Subject: [PATCH 114/189] Adjoint ode_bdf passing ode_bdf tests.
 integrate_ode_bdf not working yet. (design-doc #19)

---
 stan/math/prim/functor/ode_rk45.hpp           |   6 +-
 stan/math/rev/core/grad.hpp                   |   6 +-
 stan/math/rev/functor/cvodes_integrator.hpp   | 564 ++++++++++++++----
 stan/math/rev/functor/cvodes_utils.hpp        |   7 +-
 stan/math/rev/functor/integrate_ode_adams.hpp |   4 +-
 stan/math/rev/functor/ode_bdf.hpp             |   8 +-
 .../math/rev/functor/ode_bdf_rev_test.cpp     |  21 +-
 7 files changed, 463 insertions(+), 153 deletions(-)

diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index 5d5fd2e9e81..d45d42662af 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -163,8 +163,6 @@ ode_rk45_tol(const F& f,
   bool observer_initial_recorded = false;
   size_t time_index = 0;
 
-  max_step_checker step_checker(max_num_steps);
-
   // avoid recording of the initial state which is included by the
   // conventions of odeint in the output
   auto filtered_observer
@@ -175,7 +173,6 @@ ode_rk45_tol(const F& f,
     }
     y.emplace_back(ode_store_sensitivities(f, coupled_state, y0, t0,
                                            ts[time_index], msgs, args...));
-    step_checker.reset();
     time_index++;
   };
 
@@ -189,7 +186,8 @@ ode_rk45_tol(const F& f,
           runge_kutta_dopri5<Eigen::VectorXd, double, Eigen::VectorXd, double,
                              vector_space_algebra>()),
       std::ref(coupled_system), initial_coupled_state, std::begin(ts_vec),
-      std::end(ts_vec), step_size, filtered_observer, step_checker);
+      std::end(ts_vec), step_size, filtered_observer,
+      max_step_checker(max_num_steps));
 
   return y;
 }
diff --git a/stan/math/rev/core/grad.hpp b/stan/math/rev/core/grad.hpp
index 01b3b153fcc..b6a07530b5d 100644
--- a/stan/math/rev/core/grad.hpp
+++ b/stan/math/rev/core/grad.hpp
@@ -7,6 +7,7 @@
 #include <stan/math/rev/core/nested_size.hpp>
 #include <stan/math/rev/core/vari.hpp>
 #include <vector>
+#include <iostream>
 
 namespace stan {
 namespace math {
@@ -27,8 +28,9 @@ namespace math {
  * @param vi Variable implementation for root of partial
  * derivative propagation.
  */
-static void grad(vari* vi) {
-  vi->init_dependent();
+static void grad(vari* vi = NULL) {
+  if(vi != NULL)
+    vi->init_dependent();
   std::vector<vari*>& var_stack = ChainableStack::instance_->var_stack_;
   size_t end = var_stack.size();
   size_t beginning = empty_nested() ? 0 : end - nested_size();
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 10a6e3d059a..68952da3b86 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -2,6 +2,7 @@
 #define STAN_MATH_REV_FUNCTOR_INTEGRATE_ODE_CVODES_HPP
 
 #include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/core/save_varis.hpp>
 #include <stan/math/rev/functor/cvodes_utils.hpp>
 #include <stan/math/rev/functor/coupled_ode_system.hpp>
 #include <stan/math/rev/functor/ode_store_sensitivities.hpp>
@@ -15,6 +16,59 @@
 
 namespace stan {
 namespace math {
+  
+  template <typename T_Return>
+  std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>>
+  build_varis(vari* ode_vari, vari**& non_chaining_varis, const std::vector<Eigen::VectorXd>& y);
+  
+  template <>
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>>
+  build_varis<var>(vari* ode_vari, vari**& non_chaining_varis, const std::vector<Eigen::VectorXd>& y) {
+    std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> y_return(y.size());
+    
+    if(y.size() == 0) {
+      return y_return;
+    }
+
+    int N = y[0].size();
+
+    non_chaining_varis =
+      ChainableStack::instance_->memalloc_.alloc_array<vari*>(y.size() * N);
+
+    for (size_t i = 0; i < y.size(); i++) {
+      for (size_t j = 0; j < N; j++) {
+	// The special vari that will handle the adjoint solve corresponds to
+	// the output y[y.size() - 1][N - 1]
+	/*if (i == y.size() - 1 && j == N - 1)
+	  continue;*/
+
+	// non_chaining_varis[i * N + j] corresponds to the vari attached to
+	// the ode output at time t[i] and state j
+	non_chaining_varis[i * N + j] = new vari(y[i][j], false);
+      }
+    }
+
+    for (size_t i = 0; i < y.size(); i++) {
+      y_return[i].resize(N);
+      for (size_t j = 0; j < N; j++)
+	// Inject our special vari at y[y.size() - 1][N - 1]
+	/*if (i == y.size() - 1 && j == N - 1)
+	  y_return[i][j] = var(ode_vari);
+	  else*/
+	y_return[i][j] = var(non_chaining_varis[i * N + j]);
+    }
+
+    return y_return;
+  }
+
+  /*
+   * If theta and y are both doubles, just pass the values through (there's
+   * no autodiff to handle here).
+   */
+  template <>
+  std::vector<Eigen::VectorXd> build_varis<double>(vari* ode_vari, vari**& non_chaining_varis, const std::vector<Eigen::VectorXd>& y) {
+    return y;
+  }
 
 /**
  * Integrator interface for CVODES' ODE solvers (Adams & BDF
@@ -29,15 +83,14 @@ namespace math {
  */
 template <int Lmm, typename F, typename T_y0, typename T_t0, typename T_ts,
           typename... T_Args>
-class cvodes_integrator {
+class cvodes_integrator_vari : public vari, public chainable_alloc {
   using T_Return = return_type_t<T_y0, T_t0, T_ts, T_Args...>;
-  using T_y0_t0 = return_type_t<T_y0, T_t0>;
 
-  const F& f_;
-  const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1> y0_;
+  const F f_;
+  const Eigen::Matrix<T_y0, Eigen::Dynamic, 1> y0_;
   const T_t0 t0_;
-  const std::vector<T_ts>& ts_;
-  std::tuple<const T_Args&...> args_tuple_;
+  const std::vector<T_ts> ts_;
+  std::tuple<T_Args...> args_tuple_;
   std::tuple<decltype(value_of(T_Args()))...> value_of_args_tuple_;
   const size_t N_;
   std::ostream* msgs_;
@@ -45,38 +98,57 @@ class cvodes_integrator {
   double absolute_tolerance_;
   long int max_num_steps_;
 
+  std::vector<Eigen::VectorXd> y_;
+
+  const size_t t0_vars_;
+  const size_t ts_vars_;
   const size_t y0_vars_;
   const size_t args_vars_;
 
-  coupled_ode_system<F, T_y0_t0, T_Args...> coupled_ode_;
-
-  Eigen::VectorXd coupled_state_;
-  N_Vector nv_state_;
-  N_Vector* nv_state_sens_;
   SUNMatrix A_;
   SUNLinearSolver LS_;
+  void* cvodes_mem_;
+  vari** non_chaining_varis_;
+
+  vari** t0_varis_;
+  vari** ts_varis_;
+  vari** y0_varis_;
+  vari** args_varis_;
 
   /**
    * Implements the function of type CVRhsFn which is the user-defined
    * ODE RHS passed to CVODES.
    */
   static int cv_rhs(realtype t, N_Vector y, N_Vector ydot, void* user_data) {
-    const cvodes_integrator* integrator
-        = static_cast<const cvodes_integrator*>(user_data);
+    const cvodes_integrator_vari* integrator
+      = static_cast<const cvodes_integrator_vari*>(user_data);
     integrator->rhs(t, NV_DATA_S(y), NV_DATA_S(ydot));
     return 0;
   }
 
   /**
-   * Implements the function of type CVSensRhsFn which is the
-   * RHS of the sensitivity ODE system.
+   * Implements the function of type CVRhsFnB which is the
+   * RHS of the backward ODE system.
    */
-  static int cv_rhs_sens(int Ns, realtype t, N_Vector y, N_Vector ydot,
-                         N_Vector* yS, N_Vector* ySdot, void* user_data,
-                         N_Vector tmp1, N_Vector tmp2) {
-    const cvodes_integrator* integrator
-        = static_cast<const cvodes_integrator*>(user_data);
-    integrator->rhs_sens(t, NV_DATA_S(y), yS, ySdot);
+  static int cv_rhs_adj_sens(realtype t, N_Vector y,
+			     N_Vector yB, N_Vector yBdot,
+			     void *user_data) {
+    const cvodes_integrator_vari* integrator =
+      static_cast<const cvodes_integrator_vari*>(user_data);
+    integrator->rhs_adj_sens(t, y, yB, yBdot);
+    return 0;
+  }
+
+  /**
+   * Implements the function of type CVQuadRhsFnB which is the
+   * RHS of the backward ODE system's quadrature.
+   */
+  static int cv_quad_rhs_adj(realtype t, N_Vector y,
+			 N_Vector yB, N_Vector qBdot,
+			 void *user_data) {
+    const cvodes_integrator_vari* integrator =
+      static_cast<const cvodes_integrator_vari*>(user_data);
+    integrator->quad_rhs_adj(t, y, yB, qBdot);
     return 0;
   }
 
@@ -89,12 +161,28 @@ class cvodes_integrator {
   static int cv_jacobian_states(realtype t, N_Vector y, N_Vector fy,
                                 SUNMatrix J, void* user_data, N_Vector tmp1,
                                 N_Vector tmp2, N_Vector tmp3) {
-    const cvodes_integrator* integrator
-        = static_cast<const cvodes_integrator*>(user_data);
-    integrator->jacobian_states(t, NV_DATA_S(y), J);
+    const cvodes_integrator_vari* integrator
+        = static_cast<const cvodes_integrator_vari*>(user_data);
+    integrator->jacobian_states(t, y, J);
     return 0;
   }
 
+  /**
+   * Implements the CVLsJacFnB function for evaluating the jacobian of
+   * the adjoint problem.
+   */
+  static int cv_jacobian_adj(realtype t, N_Vector y,
+			     N_Vector yB, N_Vector fyB,
+			     SUNMatrix J, void *user_data,
+			     N_Vector tmp1, N_Vector tmp2,
+			     N_Vector tmp3) {
+    const cvodes_integrator_vari* integrator =
+      static_cast<const cvodes_integrator_vari*>(user_data);
+    integrator->jacobian_adj(t, y, J);
+    return 0;
+  }
+
+  
   /**
    * Calculates the ODE RHS, dy_dt, using the user-supplied functor at
    * the given time t and state y.
@@ -112,11 +200,98 @@ class cvodes_integrator {
     std::copy(dy_dt_vec.data(), dy_dt_vec.data() + dy_dt_vec.size(), dy_dt);
   }
 
+  /*
+   * Calculate the adjoint sensitivity RHS for varying initial conditions
+   * and parameters
+   *
+   * @param[in] initial var vector
+   * @param[in] param var vector
+   * @param[in] t time
+   * @param[in] y state of the base ODE system
+   * @param[in] yB state of the adjoint ODE system
+   * @param[out] yBdot evaluation of adjoint ODE RHS
+   */
+  void rhs_adj_sens(double t, N_Vector y,
+		    N_Vector yB, N_Vector yBdot) const {
+    Eigen::Map<Eigen::VectorXd> y_vec(NV_DATA_S(y), N_);
+    Eigen::Map<Eigen::VectorXd> lambda(NV_DATA_S(yB), N_);
+    Eigen::Map<Eigen::VectorXd> lambda_dot(NV_DATA_S(yBdot), N_);
+    lambda_dot = Eigen::VectorXd::Zero(N_);
+    
+    const nested_rev_autodiff nested;
+
+    Eigen::Matrix<var, Eigen::Dynamic, 1> y_vars(y_vec.size());
+    for (size_t i = 0; i < y_vars.size(); ++i)
+      y_vars(i) = new vari(value_of(y_vec(i)));
+
+    Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars
+      = apply([&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
+	      value_of_args_tuple_);
+
+    check_size_match("coupled_ode_system1", "dy_dt", f_y_t_vars.size(), "states",
+                     N_);
+
+    for (size_t i = 0; i < f_y_t_vars.size(); ++i) {
+      f_y_t_vars(i).vi_->adj_ = -lambda(i);
+    }
+
+    grad();
+
+    for(size_t i = 0; i < y_vars.size(); ++i) {
+      lambda_dot(i) = y_vars(i).adj();
+    }
+  }
+
+  /*
+   * Calculate the RHS for the quadrature part of the adjoint ODE problem.
+   *
+   * @param[in] initial var vector
+   * @param[in] param var vector
+   * @param[in] t time
+   * @param[in] y state of the base ODE system
+   * @param[in] yB state of the adjoint ODE system
+   * @param[out] qBdot evaluation of adjoint ODE quadrature RHS
+   */
+  void quad_rhs_adj(double t, N_Vector y,
+		    N_Vector yB, N_Vector qBdot) const {
+    Eigen::VectorXd y_vec = Eigen::Map<Eigen::VectorXd>(NV_DATA_S(y), N_);
+    Eigen::Map<Eigen::VectorXd> lambda(NV_DATA_S(yB), N_);
+    Eigen::Map<Eigen::VectorXd> mu_dot(NV_DATA_S(qBdot), N_);
+    mu_dot = Eigen::VectorXd::Zero(N_);
+
+    nested_rev_autodiff nested;
+
+    auto local_args_tuple = apply(
+        [&](auto&&... args) {
+          return std::tuple<decltype(deep_copy_vars(args))...>(
+              deep_copy_vars(args)...);
+        },
+        args_tuple_);
+
+    Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars
+      = apply([&](auto&&... args) { return f_(t, y_vec, msgs_, args...); },
+	      local_args_tuple);
+
+    check_size_match("coupled_ode_system2", "dy_dt", f_y_t_vars.size(), "states",
+                     N_);
+
+    for (size_t i = 0; i < f_y_t_vars.size(); ++i) {
+      f_y_t_vars(i).vi_->adj_ = -lambda(i);
+    }
+
+    grad();
+
+    apply([&](auto&&... args) {
+            accumulate_adjoints(mu_dot.data(), args...);
+          },
+          local_args_tuple);
+  }
+
   /**
    * Calculates the jacobian of the ODE RHS wrt to its states y at the
    * given time-point t and state y.
    */
-  inline void jacobian_states(double t, const double y[], SUNMatrix J) const {
+  inline void jacobian_states(double t, N_Vector y, SUNMatrix J) const {
     Eigen::VectorXd fy;
     Eigen::MatrixXd Jfy;
 
@@ -125,7 +300,7 @@ class cvodes_integrator {
                    value_of_args_tuple_);
     };
 
-    jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(y, N_), fy, Jfy);
+    jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(NV_DATA_S(y), N_), fy, Jfy);
 
     for (size_t j = 0; j < Jfy.cols(); ++j) {
       for (size_t i = 0; i < Jfy.rows(); ++i) {
@@ -134,25 +309,29 @@ class cvodes_integrator {
     }
   }
 
-  /**
-   * Calculates the RHS of the sensitivity ODE system which
-   * corresponds to the coupled ode system from which the first N
-   * states are omitted, since the first N states are the ODE RHS
-   * which CVODES separates from the main ODE RHS.
+  /*
+   * Calculate the Jacobian of the RHS of the adjoint ODE (see rhs_adj_sens
+   * below for citation for how this is done)
+   *
+   * @param[in] y State of system
+   * @param[in] t Time
+   * @param[out] J CVode structure where output is to be stored
    */
-  inline void rhs_sens(double t, const double y[], N_Vector* yS,
-                       N_Vector* ySdot) const {
-    Eigen::VectorXd z(coupled_state_.size());
-    Eigen::VectorXd dz_dt(coupled_state_.size());
-    std::copy(y, y + N_, z.data());
-    for (std::size_t s = 0; s < y0_vars_ + args_vars_; s++) {
-      std::copy(NV_DATA_S(yS[s]), NV_DATA_S(yS[s]) + N_,
-                z.data() + (s + 1) * N_);
-    }
-    coupled_ode_(z, dz_dt, t);
-    for (std::size_t s = 0; s < y0_vars_ + args_vars_; s++) {
-      std::move(dz_dt.data() + (s + 1) * N_, dz_dt.data() + (s + 2) * N_,
-                NV_DATA_S(ySdot[s]));
+  inline void jacobian_adj(double t, N_Vector y, SUNMatrix J) const {
+    Eigen::VectorXd fy;
+    Eigen::MatrixXd Jfy;
+
+    auto f_wrapped = [&](const Eigen::Matrix<var, Eigen::Dynamic, 1>& y) {
+      return apply([&](auto&&... args) { return f_(t, y, msgs_, args...); },
+                   value_of_args_tuple_);
+    };
+
+    jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(NV_DATA_S(y), N_), fy, Jfy);
+
+    for (size_t j = 0; j < Jfy.cols(); ++j) {
+      for (size_t i = 0; i < Jfy.rows(); ++i) {
+        SM_ELEMENT_D(J, j, i) = -Jfy(i, j);
+      }
     }
   }
 
@@ -176,29 +355,40 @@ class cvodes_integrator {
    * @return a vector of states, each state being a vector of the
    * same size as the state variable, corresponding to a time in ts.
    */
-  cvodes_integrator(const F& f,
-                    const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
-                    const T_t0& t0, const std::vector<T_ts>& ts,
-                    double relative_tolerance, double absolute_tolerance,
-                    long int max_num_steps, std::ostream* msgs,
-                    const T_Args&... args)
-      : f_(f),
-        y0_(y0.unaryExpr([](const T_y0& val) { return T_y0_t0(val); })),
-        t0_(t0),
-        ts_(ts),
-        args_tuple_(args...),
-        value_of_args_tuple_(value_of(args)...),
-        N_(y0.size()),
-        msgs_(msgs),
-        relative_tolerance_(relative_tolerance),
-        absolute_tolerance_(absolute_tolerance),
-        max_num_steps_(max_num_steps),
-        y0_vars_(count_vars(y0_)),
-        args_vars_(count_vars(args...)),
-        coupled_ode_(f, y0_, msgs, args...),
-        coupled_state_(coupled_ode_.initial_state()) {
+  cvodes_integrator_vari(const F& f,
+			 const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
+			 const T_t0& t0, const std::vector<T_ts>& ts,
+			 double relative_tolerance, double absolute_tolerance,
+			 long int max_num_steps, std::ostream* msgs,
+			 const T_Args&... args)
+    : vari(NOT_A_NUMBER),
+      f_(f),
+      y0_(y0),
+      t0_(t0),
+      ts_(ts),
+      args_tuple_(args...),
+      value_of_args_tuple_(value_of(args)...),
+      N_(y0.size()),
+      msgs_(msgs),
+      relative_tolerance_(relative_tolerance),
+      absolute_tolerance_(absolute_tolerance),
+      max_num_steps_(max_num_steps),
+      y_(ts_.size()),
+      t0_vars_(count_vars(t0_)),
+      ts_vars_(count_vars(ts_)),
+      y0_vars_(count_vars(y0_)),
+      args_vars_(count_vars(args...)),
+      t0_varis_(ChainableStack::instance_->memalloc_.alloc_array<vari*>(t0_vars_)),
+      ts_varis_(ChainableStack::instance_->memalloc_.alloc_array<vari*>(ts_vars_)),
+      y0_varis_(ChainableStack::instance_->memalloc_.alloc_array<vari*>(y0_vars_)),
+      args_varis_(ChainableStack::instance_->memalloc_.alloc_array<vari*>(args_vars_)) {
     const char* fun = "cvodes_integrator::integrate";
 
+    save_varis(t0_varis_, t0);
+    save_varis(ts_varis_, ts);
+    save_varis(y0_varis_, y0);
+    save_varis(args_varis_, args...);
+
     check_finite(fun, "initial state", y0_);
     check_finite(fun, "initial time", t0_);
     check_finite(fun, "times", ts_);
@@ -220,29 +410,20 @@ class cvodes_integrator {
     check_positive_finite(fun, "absolute_tolerance", absolute_tolerance_);
     check_positive(fun, "max_num_steps", max_num_steps_);
 
-    nv_state_ = N_VMake_Serial(N_, &coupled_state_[0]);
-    nv_state_sens_ = nullptr;
-    A_ = SUNDenseMatrix(N_, N_);
-    LS_ = SUNDenseLinearSolver(nv_state_, A_);
-
-    if (y0_vars_ + args_vars_ > 0) {
-      nv_state_sens_
-          = N_VCloneVectorArrayEmpty_Serial(y0_vars_ + args_vars_, nv_state_);
-      for (std::size_t i = 0; i < y0_vars_ + args_vars_; i++) {
-        NV_DATA_S(nv_state_sens_[i]) = &coupled_state_[N_] + i * N_;
-      }
-    }
   }
 
-  ~cvodes_integrator() {
+  ~cvodes_integrator_vari() {
+    std::cout << "FREEEEEEEEEEEEEEEEEEEEEEEDOM!" << std::endl;
+    std::cout << "FREEEEEEEEEEEEEEEEEEEEEEEDOM!" << std::endl;
+    std::cout << "FREEEEEEEEEEEEEEEEEEEEEEEDOM!" << std::endl;
+    std::cout << "FREEEEEEEEEEEEEEEEEEEEEEEDOM!" << std::endl;
+
+    // At some point in the future I should free memory
     SUNLinSolFree(LS_);
     SUNMatDestroy(A_);
-    N_VDestroy_Serial(nv_state_);
-    if (y0_vars_ + args_vars_ > 0) {
-      N_VDestroyVectorArray_Serial(nv_state_sens_, y0_vars_ + args_vars_);
-    }
+    CVodeFree(&cvodes_mem_);
   }
-
+  
   /**
    * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
    * times, { t1, t2, t3, ... } using the stiff backward differentiation formula
@@ -252,84 +433,225 @@ class cvodes_integrator {
    *   solution time (excluding the initial state)
    */
   std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>>
-  integrate() {  // NOLINT(runtime/int)
-    std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> y;
+  operator()() {
+    Eigen::VectorXd state = value_of(y0_);
+    N_Vector nv_state = N_VMake_Serial(state.size(), state.data());
+
+    A_ = SUNDenseMatrix(N_, N_);
+    LS_ = SUNDenseLinearSolver(nv_state, A_);
 
     const double t0_dbl = value_of(t0_);
     const std::vector<double> ts_dbl = value_of(ts_);
 
-    void* cvodes_mem = CVodeCreate(Lmm);
-    if (cvodes_mem == nullptr) {
+    cvodes_mem_ = CVodeCreate(Lmm);
+    if (cvodes_mem_ == nullptr) {
       throw std::runtime_error("CVodeCreate failed to allocate memory");
     }
 
     try {
       check_flag_sundials(
-          CVodeInit(cvodes_mem, &cvodes_integrator::cv_rhs, t0_dbl, nv_state_),
+          CVodeInit(cvodes_mem_, &cvodes_integrator_vari::cv_rhs, t0_dbl, nv_state),
           "CVodeInit");
 
       // Assign pointer to this as user data
       check_flag_sundials(
-          CVodeSetUserData(cvodes_mem, reinterpret_cast<void*>(this)),
+          CVodeSetUserData(cvodes_mem_, reinterpret_cast<void*>(this)),
           "CVodeSetUserData");
 
-      cvodes_set_options(cvodes_mem, relative_tolerance_, absolute_tolerance_,
+      cvodes_set_options(cvodes_mem_, relative_tolerance_, absolute_tolerance_,
                          max_num_steps_);
 
       // for the stiff solvers we need to reserve additional memory
       // and provide a Jacobian function call. new API since 3.0.0:
       // create matrix object and linear solver object; resource
       // (de-)allocation is handled in the cvodes_ode_data
-      check_flag_sundials(CVodeSetLinearSolver(cvodes_mem, LS_, A_),
+      check_flag_sundials(CVodeSetLinearSolver(cvodes_mem_, LS_, A_),
                           "CVodeSetLinearSolver");
+
       check_flag_sundials(
-          CVodeSetJacFn(cvodes_mem, &cvodes_integrator::cv_jacobian_states),
+          CVodeSetJacFn(cvodes_mem_, &cvodes_integrator_vari::cv_jacobian_states),
           "CVodeSetJacFn");
 
       // initialize forward sensitivity system of CVODES as needed
-      if (y0_vars_ + args_vars_ > 0) {
-        check_flag_sundials(
-            CVodeSensInit(cvodes_mem, static_cast<int>(y0_vars_ + args_vars_),
-                          CV_STAGGERED, &cvodes_integrator::cv_rhs_sens,
-                          nv_state_sens_),
-            "CVodeSensInit");
-
-        check_flag_sundials(CVodeSensEEtolerances(cvodes_mem),
-                            "CVodeSensEEtolerances");
+      if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ > 0) {
+	check_flag_sundials(CVodeAdjInit(cvodes_mem_, 25, CV_HERMITE),
+			  "CVodeAdjInit");
       }
 
       double t_init = t0_dbl;
       for (size_t n = 0; n < ts_.size(); ++n) {
         double t_final = ts_dbl[n];
 
-        if (t_final != t_init) {
-          check_flag_sundials(
-              CVode(cvodes_mem, t_final, nv_state_, &t_init, CV_NORMAL),
-              "CVode");
-        }
-
-        if (y0_vars_ + args_vars_ > 0) {
-          check_flag_sundials(CVodeGetSens(cvodes_mem, &t_init, nv_state_sens_),
-                              "CVodeGetSens");
-        }
-
-        y.emplace_back(apply(
-            [&](auto&&... args) {
-              return ode_store_sensitivities(f_, coupled_state_, y0_, t0_,
-                                             ts_[n], msgs_, args...);
-            },
-            args_tuple_));
+	if (t_final != t_init) {
+	  if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ > 0) {
+	    int ncheck;
+	    check_flag_sundials(CVodeF(cvodes_mem_, t_final, nv_state,
+				     &t_init, CV_NORMAL, &ncheck),
+			      "CVodeF");
+	  } else {
+	    check_flag_sundials(CVode(cvodes_mem_, t_final, nv_state,
+				    &t_init, CV_NORMAL),
+			      "CVode");
+	  }
+	}
+
+	y_[n] = state;
 
         t_init = t_final;
       }
     } catch (const std::exception& e) {
-      CVodeFree(&cvodes_mem);
+      N_VDestroy_Serial(nv_state);
       throw;
     }
 
-    CVodeFree(&cvodes_mem);
+    N_VDestroy_Serial(nv_state);
 
-    return y;
+    return build_varis<T_Return>(this, non_chaining_varis_, y_);
+  }
+
+  virtual void chain() {
+    // std::cout << "chain" << std::endl; <-- Good way to verify it's only
+    //  being called once
+    if(t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ == 0) {
+      return;
+    }
+
+    Eigen::VectorXd state_sens(N_);
+    Eigen::VectorXd quad(args_vars_);
+    N_Vector nv_state_sens = N_VMake_Serial(state_sens.size(), state_sens.data());
+    N_Vector nv_quad = N_VMake_Serial(quad.size(), quad.data());
+    N_VConst(0.0, nv_state_sens);
+    N_VConst(0.0, nv_quad);
+
+    SUNMatrix AB_ = SUNDenseMatrix(N_, N_);
+    SUNLinearSolver LSB_ = SUNDenseLinearSolver(nv_state_sens, AB_);
+
+    try {
+      int indexB;
+
+      // This is all boilerplate CVODES setting up the adjoint ODE to solve
+      check_flag_sundials(CVodeCreateB
+			(cvodes_mem_, Lmm, &indexB),
+			"CVodeCreateB");
+
+      check_flag_sundials(CVodeSetUserDataB
+			(cvodes_mem_, indexB,
+			 reinterpret_cast<void*>(this)),
+			"CVodeSetUserDataB");
+
+      // The ode_rhs_adj_sense functions passed in here cause problems with
+      // the autodiff stack (they can cause reallocations of the internal
+      // vectors and cause segfaults)
+      check_flag_sundials(CVodeInitB(cvodes_mem_,
+				     indexB,
+				     &cvodes_integrator_vari::cv_rhs_adj_sens,
+				     value_of(ts_.back()),
+				     nv_state_sens),
+			"CVodeInitB");
+      
+      check_flag_sundials(CVodeSStolerancesB(cvodes_mem_,
+					   indexB,
+					   relative_tolerance_,
+					   absolute_tolerance_),
+			"CVodeSStolerancesB");
+
+      check_flag_sundials(CVodeSetLinearSolverB(cvodes_mem_, indexB, LSB_, AB_),
+			"CVodeSetLinearSolverB");
+
+      // The same autodiff issue that applies to ode_rhs_adj_sense applies
+      // here
+      check_flag_sundials(CVodeSetJacFnB
+			(cvodes_mem_, indexB,
+			 &cvodes_integrator_vari::cv_jacobian_adj),
+			"CVodeSetJacFnB");
+
+      // Allocate space for backwards quadrature
+      if(args_vars_ > 0) {
+	check_flag_sundials(CVodeQuadInitB(cvodes_mem_,
+					   indexB,
+					   &cvodes_integrator_vari::cv_quad_rhs_adj,
+					   nv_quad),
+			    "CVodeQuadInitB");
+
+	check_flag_sundials(CVodeQuadSStolerancesB(cvodes_mem_,
+						   indexB,
+						  relative_tolerance_,
+						  absolute_tolerance_),
+			    "CVodeQuadSStolerancesB");
+
+	check_flag_sundials(CVodeSetQuadErrConB(cvodes_mem_,
+						indexB,
+						SUNTRUE),
+			    "CVodeSetQuadErrConB");
+      }
+
+      // At every time step, collect the adjoints from the output
+      // variables and re-initialize the solver
+      double t_init = value_of(ts_.back());
+      for (int i = ts_.size() - 1; i >= 0; --i) {
+	// Take in the adjoints from all the output variables at this point
+	// in time
+	for (int j = 0; j < N_; j++) {
+	  state_sens(j) += non_chaining_varis_[i * N_ + j]->adj_;
+	}
+
+	if (ts_vars_ > 0 && i >= 0) {
+	  ts_varis_[i]->adj_ += apply([&](auto&&... args) {
+	      return state_sens.dot(f_(t_init, y_[i], msgs_, args...));
+	    }, value_of_args_tuple_);
+	}
+
+	double t_final = value_of((i > 0) ? ts_[i - 1] : t0_);
+        if (t_final != t_init) {
+	  check_flag_sundials(CVodeReInitB(cvodes_mem_, indexB, t_init,
+					   nv_state_sens),
+			      "CVodeReInitB");
+
+	  check_flag_sundials(CVodeB(cvodes_mem_, t_final,
+				     CV_NORMAL),
+			      "CVodeB");
+
+	  check_flag_sundials(CVodeGetB(cvodes_mem_, indexB, &t_init,
+					nv_state_sens),
+			      "CVodeGetB");
+	}
+      }
+      
+      if(t0_vars_ > 0) {
+	t0_varis_[0]->adj_ += apply([&](auto&&... args) {
+	    return -state_sens.dot(f_(t_init, value_of(y0_), msgs_, args...));
+	  }, value_of_args_tuple_);
+      }
+
+      if(args_vars_ > 0) {
+	check_flag_sundials(CVodeGetQuadB(cvodes_mem_, indexB, &t_init,
+					  nv_quad),
+			    "CVodeGetQuadB");
+      }
+
+      // After integrating all the way back to t0, we finally have the
+      // the adjoints we wanted
+      // These are the dlog_density / d(initial_conditions[s]) adjoints
+      for (size_t s = 0; s < y0_vars_; s++) {
+	y0_varis_[s]->adj_ += state_sens(s);
+      }
+      
+      // These are the dlog_density / d(parameters[s]) adjoints
+      for (size_t s = 0; s < args_vars_; s++) {
+	args_varis_[s]->adj_ += quad(s);
+      }
+    } catch (const std::exception& e) {
+      SUNLinSolFree(LSB_);
+      SUNMatDestroy(AB_);
+      N_VDestroy_Serial(nv_state_sens);
+      N_VDestroy_Serial(nv_quad);
+      throw;
+    }
+
+    SUNLinSolFree(LSB_);
+    SUNMatDestroy(AB_);
+    N_VDestroy_Serial(nv_state_sens);
+    N_VDestroy_Serial(nv_quad);
   }
 };  // cvodes integrator
 
diff --git a/stan/math/rev/functor/cvodes_utils.hpp b/stan/math/rev/functor/cvodes_utils.hpp
index 7b5602a0ee6..ff253bbe4d5 100644
--- a/stan/math/rev/functor/cvodes_utils.hpp
+++ b/stan/math/rev/functor/cvodes_utils.hpp
@@ -15,7 +15,12 @@ namespace math {
 extern "C" inline void cvodes_silent_err_handler(int error_code,
                                                  const char* module,
                                                  const char* function,
-                                                 char* msg, void* eh_data) {}
+                                                 char* msg, void* eh_data) {
+  // I found it handy to make this non-silent to debug CVODES while I set up
+  // the adjoint sensitivity. I'm keeping this here for now
+  std::cout << "Error " << msg << " (" << error_code << ") in " <<
+    module << ", " << function << std::endl;
+}
 
 inline void cvodes_set_options(void* cvodes_mem, double rel_tol, double abs_tol,
                                // NOLINTNEXTLINE(runtime/int)
diff --git a/stan/math/rev/functor/integrate_ode_adams.hpp b/stan/math/rev/functor/integrate_ode_adams.hpp
index d6c0d2bca21..835413f6e1e 100644
--- a/stan/math/rev/functor/integrate_ode_adams.hpp
+++ b/stan/math/rev/functor/integrate_ode_adams.hpp
@@ -9,7 +9,7 @@
 namespace stan {
 namespace math {
 
-template <typename F, typename T_initial, typename T_param, typename T_t0,
+  /*template <typename F, typename T_initial, typename T_param, typename T_t0,
           typename T_ts>
 std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>>
 integrate_ode_adams(const F& f, const std::vector<T_initial>& y0,
@@ -26,7 +26,7 @@ integrate_ode_adams(const F& f, const std::vector<T_initial>& y0,
       integrator(f, y0, t0, ts, theta, x, x_int, msgs, relative_tolerance,
                  absolute_tolerance, max_num_steps);
   return integrator.integrate();
-}
+  }*/
 
 }  // namespace math
 }  // namespace stan
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 7e63d1fb36b..1082b8a49b6 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -99,11 +99,11 @@ ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
             const T_t0& t0, const std::vector<T_ts>& ts,
             double relative_tolerance, double absolute_tolerance,
             long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
-  stan::math::cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...>
-  integrator(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
-             max_num_steps, msgs, args...);
+  auto integrator =
+    new stan::math::cvodes_integrator_vari<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...>
+    (f, y0, t0, ts, relative_tolerance, absolute_tolerance, max_num_steps, msgs, args...);
 
-  return integrator.integrate();
+  return (*integrator)();
 }
 
 }  // namespace math
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index 1165a58e82e..8e48ec8acbf 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -128,9 +128,9 @@ TEST(StanMathOde_ode_bdf_tol, std_vector_arg) {
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0.0;
-  std::vector<double> ts = {1.1};
+  std::vector<double> ts = { 1.1 };
 
-  std::vector<var> a = {1.5};
+  std::vector<var> a = { 1.5 };
 
   var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
                                        nullptr, a)[0][0];
@@ -226,23 +226,6 @@ struct ayt {
   }
 };
 
-void check_t0(const var& t0) { EXPECT_FLOAT_EQ(t0.adj(), -1.0); }
-
-void check_t0(double t0) {}
-
-void check_ts(const std::vector<var>& ts) {
-  EXPECT_FLOAT_EQ(ts[0].adj(), 0.0);
-  EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
-}
-
-void check_ts(const std::vector<double>& ts) {}
-
-void check_y0(const Eigen::Matrix<var, Eigen::Dynamic, 1>& y0) {
-  EXPECT_FLOAT_EQ(y0(0).adj(), 0.5);
-}
-
-void check_y0(const Eigen::MatrixXd& y0) {}
-
 TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   var t0 = 0.5;
   var a = 0.2;

From 92314d09ba3c0f2c8d5a75f51e3525cacdfc472a Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 15 May 2020 20:07:19 -0400
Subject: [PATCH 115/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 stan/math/rev/core/grad.hpp                   |   2 +-
 stan/math/rev/functor/cvodes_integrator.hpp   | 416 +++++++++---------
 stan/math/rev/functor/cvodes_utils.hpp        |   4 +-
 stan/math/rev/functor/integrate_ode_adams.hpp |  32 +-
 stan/math/rev/functor/ode_bdf.hpp             |   8 +-
 .../math/rev/functor/ode_bdf_rev_test.cpp     |   4 +-
 6 files changed, 232 insertions(+), 234 deletions(-)

diff --git a/stan/math/rev/core/grad.hpp b/stan/math/rev/core/grad.hpp
index b6a07530b5d..15d4d720bc4 100644
--- a/stan/math/rev/core/grad.hpp
+++ b/stan/math/rev/core/grad.hpp
@@ -29,7 +29,7 @@ namespace math {
  * derivative propagation.
  */
 static void grad(vari* vi = NULL) {
-  if(vi != NULL)
+  if (vi != NULL)
     vi->init_dependent();
   std::vector<vari*>& var_stack = ChainableStack::instance_->var_stack_;
   size_t end = var_stack.size();
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 68952da3b86..a9c716b1a2e 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -16,60 +16,64 @@
 
 namespace stan {
 namespace math {
-  
-  template <typename T_Return>
-  std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>>
-  build_varis(vari* ode_vari, vari**& non_chaining_varis, const std::vector<Eigen::VectorXd>& y);
-  
-  template <>
-  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>>
-  build_varis<var>(vari* ode_vari, vari**& non_chaining_varis, const std::vector<Eigen::VectorXd>& y) {
-    std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> y_return(y.size());
-    
-    if(y.size() == 0) {
-      return y_return;
-    }
 
-    int N = y[0].size();
+template <typename T_Return>
+std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> build_varis(
+    vari* ode_vari, vari**& non_chaining_varis,
+    const std::vector<Eigen::VectorXd>& y);
 
-    non_chaining_varis =
-      ChainableStack::instance_->memalloc_.alloc_array<vari*>(y.size() * N);
+template <>
+std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> build_varis<var>(
+    vari* ode_vari, vari**& non_chaining_varis,
+    const std::vector<Eigen::VectorXd>& y) {
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> y_return(y.size());
 
-    for (size_t i = 0; i < y.size(); i++) {
-      for (size_t j = 0; j < N; j++) {
-	// The special vari that will handle the adjoint solve corresponds to
-	// the output y[y.size() - 1][N - 1]
-	/*if (i == y.size() - 1 && j == N - 1)
-	  continue;*/
+  if (y.size() == 0) {
+    return y_return;
+  }
 
-	// non_chaining_varis[i * N + j] corresponds to the vari attached to
-	// the ode output at time t[i] and state j
-	non_chaining_varis[i * N + j] = new vari(y[i][j], false);
-      }
-    }
+  int N = y[0].size();
 
-    for (size_t i = 0; i < y.size(); i++) {
-      y_return[i].resize(N);
-      for (size_t j = 0; j < N; j++)
-	// Inject our special vari at y[y.size() - 1][N - 1]
-	/*if (i == y.size() - 1 && j == N - 1)
-	  y_return[i][j] = var(ode_vari);
-	  else*/
-	y_return[i][j] = var(non_chaining_varis[i * N + j]);
-    }
+  non_chaining_varis
+      = ChainableStack::instance_->memalloc_.alloc_array<vari*>(y.size() * N);
 
-    return y_return;
+  for (size_t i = 0; i < y.size(); i++) {
+    for (size_t j = 0; j < N; j++) {
+      // The special vari that will handle the adjoint solve corresponds to
+      // the output y[y.size() - 1][N - 1]
+      /*if (i == y.size() - 1 && j == N - 1)
+        continue;*/
+
+      // non_chaining_varis[i * N + j] corresponds to the vari attached to
+      // the ode output at time t[i] and state j
+      non_chaining_varis[i * N + j] = new vari(y[i][j], false);
+    }
   }
 
-  /*
-   * If theta and y are both doubles, just pass the values through (there's
-   * no autodiff to handle here).
-   */
-  template <>
-  std::vector<Eigen::VectorXd> build_varis<double>(vari* ode_vari, vari**& non_chaining_varis, const std::vector<Eigen::VectorXd>& y) {
-    return y;
+  for (size_t i = 0; i < y.size(); i++) {
+    y_return[i].resize(N);
+    for (size_t j = 0; j < N; j++)
+      // Inject our special vari at y[y.size() - 1][N - 1]
+      /*if (i == y.size() - 1 && j == N - 1)
+        y_return[i][j] = var(ode_vari);
+        else*/
+      y_return[i][j] = var(non_chaining_varis[i * N + j]);
   }
 
+  return y_return;
+}
+
+/*
+ * If theta and y are both doubles, just pass the values through (there's
+ * no autodiff to handle here).
+ */
+template <>
+std::vector<Eigen::VectorXd> build_varis<double>(
+    vari* ode_vari, vari**& non_chaining_varis,
+    const std::vector<Eigen::VectorXd>& y) {
+  return y;
+}
+
 /**
  * Integrator interface for CVODES' ODE solvers (Adams & BDF
  * methods).
@@ -121,7 +125,7 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
    */
   static int cv_rhs(realtype t, N_Vector y, N_Vector ydot, void* user_data) {
     const cvodes_integrator_vari* integrator
-      = static_cast<const cvodes_integrator_vari*>(user_data);
+        = static_cast<const cvodes_integrator_vari*>(user_data);
     integrator->rhs(t, NV_DATA_S(y), NV_DATA_S(ydot));
     return 0;
   }
@@ -130,11 +134,10 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
    * Implements the function of type CVRhsFnB which is the
    * RHS of the backward ODE system.
    */
-  static int cv_rhs_adj_sens(realtype t, N_Vector y,
-			     N_Vector yB, N_Vector yBdot,
-			     void *user_data) {
-    const cvodes_integrator_vari* integrator =
-      static_cast<const cvodes_integrator_vari*>(user_data);
+  static int cv_rhs_adj_sens(realtype t, N_Vector y, N_Vector yB,
+                             N_Vector yBdot, void* user_data) {
+    const cvodes_integrator_vari* integrator
+        = static_cast<const cvodes_integrator_vari*>(user_data);
     integrator->rhs_adj_sens(t, y, yB, yBdot);
     return 0;
   }
@@ -143,11 +146,10 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
    * Implements the function of type CVQuadRhsFnB which is the
    * RHS of the backward ODE system's quadrature.
    */
-  static int cv_quad_rhs_adj(realtype t, N_Vector y,
-			 N_Vector yB, N_Vector qBdot,
-			 void *user_data) {
-    const cvodes_integrator_vari* integrator =
-      static_cast<const cvodes_integrator_vari*>(user_data);
+  static int cv_quad_rhs_adj(realtype t, N_Vector y, N_Vector yB,
+                             N_Vector qBdot, void* user_data) {
+    const cvodes_integrator_vari* integrator
+        = static_cast<const cvodes_integrator_vari*>(user_data);
     integrator->quad_rhs_adj(t, y, yB, qBdot);
     return 0;
   }
@@ -171,18 +173,15 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
    * Implements the CVLsJacFnB function for evaluating the jacobian of
    * the adjoint problem.
    */
-  static int cv_jacobian_adj(realtype t, N_Vector y,
-			     N_Vector yB, N_Vector fyB,
-			     SUNMatrix J, void *user_data,
-			     N_Vector tmp1, N_Vector tmp2,
-			     N_Vector tmp3) {
-    const cvodes_integrator_vari* integrator =
-      static_cast<const cvodes_integrator_vari*>(user_data);
+  static int cv_jacobian_adj(realtype t, N_Vector y, N_Vector yB, N_Vector fyB,
+                             SUNMatrix J, void* user_data, N_Vector tmp1,
+                             N_Vector tmp2, N_Vector tmp3) {
+    const cvodes_integrator_vari* integrator
+        = static_cast<const cvodes_integrator_vari*>(user_data);
     integrator->jacobian_adj(t, y, J);
     return 0;
   }
 
-  
   /**
    * Calculates the ODE RHS, dy_dt, using the user-supplied functor at
    * the given time t and state y.
@@ -211,13 +210,12 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
    * @param[in] yB state of the adjoint ODE system
    * @param[out] yBdot evaluation of adjoint ODE RHS
    */
-  void rhs_adj_sens(double t, N_Vector y,
-		    N_Vector yB, N_Vector yBdot) const {
+  void rhs_adj_sens(double t, N_Vector y, N_Vector yB, N_Vector yBdot) const {
     Eigen::Map<Eigen::VectorXd> y_vec(NV_DATA_S(y), N_);
     Eigen::Map<Eigen::VectorXd> lambda(NV_DATA_S(yB), N_);
     Eigen::Map<Eigen::VectorXd> lambda_dot(NV_DATA_S(yBdot), N_);
     lambda_dot = Eigen::VectorXd::Zero(N_);
-    
+
     const nested_rev_autodiff nested;
 
     Eigen::Matrix<var, Eigen::Dynamic, 1> y_vars(y_vec.size());
@@ -225,11 +223,11 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
       y_vars(i) = new vari(value_of(y_vec(i)));
 
     Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars
-      = apply([&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
-	      value_of_args_tuple_);
+        = apply([&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
+                value_of_args_tuple_);
 
-    check_size_match("coupled_ode_system1", "dy_dt", f_y_t_vars.size(), "states",
-                     N_);
+    check_size_match("coupled_ode_system1", "dy_dt", f_y_t_vars.size(),
+                     "states", N_);
 
     for (size_t i = 0; i < f_y_t_vars.size(); ++i) {
       f_y_t_vars(i).vi_->adj_ = -lambda(i);
@@ -237,7 +235,7 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
 
     grad();
 
-    for(size_t i = 0; i < y_vars.size(); ++i) {
+    for (size_t i = 0; i < y_vars.size(); ++i) {
       lambda_dot(i) = y_vars(i).adj();
     }
   }
@@ -252,8 +250,7 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
    * @param[in] yB state of the adjoint ODE system
    * @param[out] qBdot evaluation of adjoint ODE quadrature RHS
    */
-  void quad_rhs_adj(double t, N_Vector y,
-		    N_Vector yB, N_Vector qBdot) const {
+  void quad_rhs_adj(double t, N_Vector y, N_Vector yB, N_Vector qBdot) const {
     Eigen::VectorXd y_vec = Eigen::Map<Eigen::VectorXd>(NV_DATA_S(y), N_);
     Eigen::Map<Eigen::VectorXd> lambda(NV_DATA_S(yB), N_);
     Eigen::Map<Eigen::VectorXd> mu_dot(NV_DATA_S(qBdot), N_);
@@ -269,11 +266,11 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
         args_tuple_);
 
     Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars
-      = apply([&](auto&&... args) { return f_(t, y_vec, msgs_, args...); },
-	      local_args_tuple);
+        = apply([&](auto&&... args) { return f_(t, y_vec, msgs_, args...); },
+                local_args_tuple);
 
-    check_size_match("coupled_ode_system2", "dy_dt", f_y_t_vars.size(), "states",
-                     N_);
+    check_size_match("coupled_ode_system2", "dy_dt", f_y_t_vars.size(),
+                     "states", N_);
 
     for (size_t i = 0; i < f_y_t_vars.size(); ++i) {
       f_y_t_vars(i).vi_->adj_ = -lambda(i);
@@ -281,9 +278,7 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
 
     grad();
 
-    apply([&](auto&&... args) {
-            accumulate_adjoints(mu_dot.data(), args...);
-          },
+    apply([&](auto&&... args) { accumulate_adjoints(mu_dot.data(), args...); },
           local_args_tuple);
   }
 
@@ -300,7 +295,8 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
                    value_of_args_tuple_);
     };
 
-    jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(NV_DATA_S(y), N_), fy, Jfy);
+    jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(NV_DATA_S(y), N_), fy,
+             Jfy);
 
     for (size_t j = 0; j < Jfy.cols(); ++j) {
       for (size_t i = 0; i < Jfy.rows(); ++i) {
@@ -326,7 +322,8 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
                    value_of_args_tuple_);
     };
 
-    jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(NV_DATA_S(y), N_), fy, Jfy);
+    jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(NV_DATA_S(y), N_), fy,
+             Jfy);
 
     for (size_t j = 0; j < Jfy.cols(); ++j) {
       for (size_t i = 0; i < Jfy.rows(); ++i) {
@@ -356,32 +353,36 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
    * same size as the state variable, corresponding to a time in ts.
    */
   cvodes_integrator_vari(const F& f,
-			 const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
-			 const T_t0& t0, const std::vector<T_ts>& ts,
-			 double relative_tolerance, double absolute_tolerance,
-			 long int max_num_steps, std::ostream* msgs,
-			 const T_Args&... args)
-    : vari(NOT_A_NUMBER),
-      f_(f),
-      y0_(y0),
-      t0_(t0),
-      ts_(ts),
-      args_tuple_(args...),
-      value_of_args_tuple_(value_of(args)...),
-      N_(y0.size()),
-      msgs_(msgs),
-      relative_tolerance_(relative_tolerance),
-      absolute_tolerance_(absolute_tolerance),
-      max_num_steps_(max_num_steps),
-      y_(ts_.size()),
-      t0_vars_(count_vars(t0_)),
-      ts_vars_(count_vars(ts_)),
-      y0_vars_(count_vars(y0_)),
-      args_vars_(count_vars(args...)),
-      t0_varis_(ChainableStack::instance_->memalloc_.alloc_array<vari*>(t0_vars_)),
-      ts_varis_(ChainableStack::instance_->memalloc_.alloc_array<vari*>(ts_vars_)),
-      y0_varis_(ChainableStack::instance_->memalloc_.alloc_array<vari*>(y0_vars_)),
-      args_varis_(ChainableStack::instance_->memalloc_.alloc_array<vari*>(args_vars_)) {
+                         const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
+                         const T_t0& t0, const std::vector<T_ts>& ts,
+                         double relative_tolerance, double absolute_tolerance,
+                         long int max_num_steps, std::ostream* msgs,
+                         const T_Args&... args)
+      : vari(NOT_A_NUMBER),
+        f_(f),
+        y0_(y0),
+        t0_(t0),
+        ts_(ts),
+        args_tuple_(args...),
+        value_of_args_tuple_(value_of(args)...),
+        N_(y0.size()),
+        msgs_(msgs),
+        relative_tolerance_(relative_tolerance),
+        absolute_tolerance_(absolute_tolerance),
+        max_num_steps_(max_num_steps),
+        y_(ts_.size()),
+        t0_vars_(count_vars(t0_)),
+        ts_vars_(count_vars(ts_)),
+        y0_vars_(count_vars(y0_)),
+        args_vars_(count_vars(args...)),
+        t0_varis_(
+            ChainableStack::instance_->memalloc_.alloc_array<vari*>(t0_vars_)),
+        ts_varis_(
+            ChainableStack::instance_->memalloc_.alloc_array<vari*>(ts_vars_)),
+        y0_varis_(
+            ChainableStack::instance_->memalloc_.alloc_array<vari*>(y0_vars_)),
+        args_varis_(ChainableStack::instance_->memalloc_.alloc_array<vari*>(
+            args_vars_)) {
     const char* fun = "cvodes_integrator::integrate";
 
     save_varis(t0_varis_, t0);
@@ -409,7 +410,6 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
     check_positive_finite(fun, "relative_tolerance", relative_tolerance_);
     check_positive_finite(fun, "absolute_tolerance", absolute_tolerance_);
     check_positive(fun, "max_num_steps", max_num_steps_);
-
   }
 
   ~cvodes_integrator_vari() {
@@ -423,7 +423,7 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
     SUNMatDestroy(A_);
     CVodeFree(&cvodes_mem_);
   }
-  
+
   /**
    * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
    * times, { t1, t2, t3, ... } using the stiff backward differentiation formula
@@ -432,8 +432,7 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
    * @return std::vector of Eigen::Matrix of the states of the ODE, one for each
    *   solution time (excluding the initial state)
    */
-  std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>>
-  operator()() {
+  std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> operator()() {
     Eigen::VectorXd state = value_of(y0_);
     N_Vector nv_state = N_VMake_Serial(state.size(), state.data());
 
@@ -450,7 +449,8 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
 
     try {
       check_flag_sundials(
-          CVodeInit(cvodes_mem_, &cvodes_integrator_vari::cv_rhs, t0_dbl, nv_state),
+          CVodeInit(cvodes_mem_, &cvodes_integrator_vari::cv_rhs, t0_dbl,
+                    nv_state),
           "CVodeInit");
 
       // Assign pointer to this as user data
@@ -469,33 +469,34 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
                           "CVodeSetLinearSolver");
 
       check_flag_sundials(
-          CVodeSetJacFn(cvodes_mem_, &cvodes_integrator_vari::cv_jacobian_states),
+          CVodeSetJacFn(cvodes_mem_,
+                        &cvodes_integrator_vari::cv_jacobian_states),
           "CVodeSetJacFn");
 
       // initialize forward sensitivity system of CVODES as needed
       if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ > 0) {
-	check_flag_sundials(CVodeAdjInit(cvodes_mem_, 25, CV_HERMITE),
-			  "CVodeAdjInit");
+        check_flag_sundials(CVodeAdjInit(cvodes_mem_, 25, CV_HERMITE),
+                            "CVodeAdjInit");
       }
 
       double t_init = t0_dbl;
       for (size_t n = 0; n < ts_.size(); ++n) {
         double t_final = ts_dbl[n];
 
-	if (t_final != t_init) {
-	  if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ > 0) {
-	    int ncheck;
-	    check_flag_sundials(CVodeF(cvodes_mem_, t_final, nv_state,
-				     &t_init, CV_NORMAL, &ncheck),
-			      "CVodeF");
-	  } else {
-	    check_flag_sundials(CVode(cvodes_mem_, t_final, nv_state,
-				    &t_init, CV_NORMAL),
-			      "CVode");
-	  }
-	}
-
-	y_[n] = state;
+        if (t_final != t_init) {
+          if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ > 0) {
+            int ncheck;
+            check_flag_sundials(CVodeF(cvodes_mem_, t_final, nv_state, &t_init,
+                                       CV_NORMAL, &ncheck),
+                                "CVodeF");
+          } else {
+            check_flag_sundials(
+                CVode(cvodes_mem_, t_final, nv_state, &t_init, CV_NORMAL),
+                "CVode");
+          }
+        }
+
+        y_[n] = state;
 
         t_init = t_final;
       }
@@ -512,13 +513,14 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
   virtual void chain() {
     // std::cout << "chain" << std::endl; <-- Good way to verify it's only
     //  being called once
-    if(t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ == 0) {
+    if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ == 0) {
       return;
     }
 
     Eigen::VectorXd state_sens(N_);
     Eigen::VectorXd quad(args_vars_);
-    N_Vector nv_state_sens = N_VMake_Serial(state_sens.size(), state_sens.data());
+    N_Vector nv_state_sens
+        = N_VMake_Serial(state_sens.size(), state_sens.data());
     N_Vector nv_quad = N_VMake_Serial(quad.size(), quad.data());
     N_VConst(0.0, nv_state_sens);
     N_VConst(0.0, nv_quad);
@@ -530,115 +532,109 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
       int indexB;
 
       // This is all boilerplate CVODES setting up the adjoint ODE to solve
-      check_flag_sundials(CVodeCreateB
-			(cvodes_mem_, Lmm, &indexB),
-			"CVodeCreateB");
+      check_flag_sundials(CVodeCreateB(cvodes_mem_, Lmm, &indexB),
+                          "CVodeCreateB");
 
-      check_flag_sundials(CVodeSetUserDataB
-			(cvodes_mem_, indexB,
-			 reinterpret_cast<void*>(this)),
-			"CVodeSetUserDataB");
+      check_flag_sundials(
+          CVodeSetUserDataB(cvodes_mem_, indexB, reinterpret_cast<void*>(this)),
+          "CVodeSetUserDataB");
 
       // The ode_rhs_adj_sense functions passed in here cause problems with
       // the autodiff stack (they can cause reallocations of the internal
       // vectors and cause segfaults)
-      check_flag_sundials(CVodeInitB(cvodes_mem_,
-				     indexB,
-				     &cvodes_integrator_vari::cv_rhs_adj_sens,
-				     value_of(ts_.back()),
-				     nv_state_sens),
-			"CVodeInitB");
-      
-      check_flag_sundials(CVodeSStolerancesB(cvodes_mem_,
-					   indexB,
-					   relative_tolerance_,
-					   absolute_tolerance_),
-			"CVodeSStolerancesB");
+      check_flag_sundials(CVodeInitB(cvodes_mem_, indexB,
+                                     &cvodes_integrator_vari::cv_rhs_adj_sens,
+                                     value_of(ts_.back()), nv_state_sens),
+                          "CVodeInitB");
+
+      check_flag_sundials(
+          CVodeSStolerancesB(cvodes_mem_, indexB, relative_tolerance_,
+                             absolute_tolerance_),
+          "CVodeSStolerancesB");
 
       check_flag_sundials(CVodeSetLinearSolverB(cvodes_mem_, indexB, LSB_, AB_),
-			"CVodeSetLinearSolverB");
+                          "CVodeSetLinearSolverB");
 
       // The same autodiff issue that applies to ode_rhs_adj_sense applies
       // here
-      check_flag_sundials(CVodeSetJacFnB
-			(cvodes_mem_, indexB,
-			 &cvodes_integrator_vari::cv_jacobian_adj),
-			"CVodeSetJacFnB");
+      check_flag_sundials(
+          CVodeSetJacFnB(cvodes_mem_, indexB,
+                         &cvodes_integrator_vari::cv_jacobian_adj),
+          "CVodeSetJacFnB");
 
       // Allocate space for backwards quadrature
-      if(args_vars_ > 0) {
-	check_flag_sundials(CVodeQuadInitB(cvodes_mem_,
-					   indexB,
-					   &cvodes_integrator_vari::cv_quad_rhs_adj,
-					   nv_quad),
-			    "CVodeQuadInitB");
-
-	check_flag_sundials(CVodeQuadSStolerancesB(cvodes_mem_,
-						   indexB,
-						  relative_tolerance_,
-						  absolute_tolerance_),
-			    "CVodeQuadSStolerancesB");
-
-	check_flag_sundials(CVodeSetQuadErrConB(cvodes_mem_,
-						indexB,
-						SUNTRUE),
-			    "CVodeSetQuadErrConB");
+      if (args_vars_ > 0) {
+        check_flag_sundials(
+            CVodeQuadInitB(cvodes_mem_, indexB,
+                           &cvodes_integrator_vari::cv_quad_rhs_adj, nv_quad),
+            "CVodeQuadInitB");
+
+        check_flag_sundials(
+            CVodeQuadSStolerancesB(cvodes_mem_, indexB, relative_tolerance_,
+                                   absolute_tolerance_),
+            "CVodeQuadSStolerancesB");
+
+        check_flag_sundials(CVodeSetQuadErrConB(cvodes_mem_, indexB, SUNTRUE),
+                            "CVodeSetQuadErrConB");
       }
 
       // At every time step, collect the adjoints from the output
       // variables and re-initialize the solver
       double t_init = value_of(ts_.back());
       for (int i = ts_.size() - 1; i >= 0; --i) {
-	// Take in the adjoints from all the output variables at this point
-	// in time
-	for (int j = 0; j < N_; j++) {
-	  state_sens(j) += non_chaining_varis_[i * N_ + j]->adj_;
-	}
-
-	if (ts_vars_ > 0 && i >= 0) {
-	  ts_varis_[i]->adj_ += apply([&](auto&&... args) {
-	      return state_sens.dot(f_(t_init, y_[i], msgs_, args...));
-	    }, value_of_args_tuple_);
-	}
-
-	double t_final = value_of((i > 0) ? ts_[i - 1] : t0_);
+        // Take in the adjoints from all the output variables at this point
+        // in time
+        for (int j = 0; j < N_; j++) {
+          state_sens(j) += non_chaining_varis_[i * N_ + j]->adj_;
+        }
+
+        if (ts_vars_ > 0 && i >= 0) {
+          ts_varis_[i]->adj_ += apply(
+              [&](auto&&... args) {
+                return state_sens.dot(f_(t_init, y_[i], msgs_, args...));
+              },
+              value_of_args_tuple_);
+        }
+
+        double t_final = value_of((i > 0) ? ts_[i - 1] : t0_);
         if (t_final != t_init) {
-	  check_flag_sundials(CVodeReInitB(cvodes_mem_, indexB, t_init,
-					   nv_state_sens),
-			      "CVodeReInitB");
-
-	  check_flag_sundials(CVodeB(cvodes_mem_, t_final,
-				     CV_NORMAL),
-			      "CVodeB");
-
-	  check_flag_sundials(CVodeGetB(cvodes_mem_, indexB, &t_init,
-					nv_state_sens),
-			      "CVodeGetB");
-	}
+          check_flag_sundials(
+              CVodeReInitB(cvodes_mem_, indexB, t_init, nv_state_sens),
+              "CVodeReInitB");
+
+          check_flag_sundials(CVodeB(cvodes_mem_, t_final, CV_NORMAL),
+                              "CVodeB");
+
+          check_flag_sundials(
+              CVodeGetB(cvodes_mem_, indexB, &t_init, nv_state_sens),
+              "CVodeGetB");
+        }
       }
-      
-      if(t0_vars_ > 0) {
-	t0_varis_[0]->adj_ += apply([&](auto&&... args) {
-	    return -state_sens.dot(f_(t_init, value_of(y0_), msgs_, args...));
-	  }, value_of_args_tuple_);
+
+      if (t0_vars_ > 0) {
+        t0_varis_[0]->adj_ += apply(
+            [&](auto&&... args) {
+              return -state_sens.dot(f_(t_init, value_of(y0_), msgs_, args...));
+            },
+            value_of_args_tuple_);
       }
 
-      if(args_vars_ > 0) {
-	check_flag_sundials(CVodeGetQuadB(cvodes_mem_, indexB, &t_init,
-					  nv_quad),
-			    "CVodeGetQuadB");
+      if (args_vars_ > 0) {
+        check_flag_sundials(
+            CVodeGetQuadB(cvodes_mem_, indexB, &t_init, nv_quad),
+            "CVodeGetQuadB");
       }
 
       // After integrating all the way back to t0, we finally have the
       // the adjoints we wanted
       // These are the dlog_density / d(initial_conditions[s]) adjoints
       for (size_t s = 0; s < y0_vars_; s++) {
-	y0_varis_[s]->adj_ += state_sens(s);
+        y0_varis_[s]->adj_ += state_sens(s);
       }
-      
+
       // These are the dlog_density / d(parameters[s]) adjoints
       for (size_t s = 0; s < args_vars_; s++) {
-	args_varis_[s]->adj_ += quad(s);
+        args_varis_[s]->adj_ += quad(s);
       }
     } catch (const std::exception& e) {
       SUNLinSolFree(LSB_);
diff --git a/stan/math/rev/functor/cvodes_utils.hpp b/stan/math/rev/functor/cvodes_utils.hpp
index ff253bbe4d5..270e6c8dfd2 100644
--- a/stan/math/rev/functor/cvodes_utils.hpp
+++ b/stan/math/rev/functor/cvodes_utils.hpp
@@ -18,8 +18,8 @@ extern "C" inline void cvodes_silent_err_handler(int error_code,
                                                  char* msg, void* eh_data) {
   // I found it handy to make this non-silent to debug CVODES while I set up
   // the adjoint sensitivity. I'm keeping this here for now
-  std::cout << "Error " << msg << " (" << error_code << ") in " <<
-    module << ", " << function << std::endl;
+  std::cout << "Error " << msg << " (" << error_code << ") in " << module
+            << ", " << function << std::endl;
 }
 
 inline void cvodes_set_options(void* cvodes_mem, double rel_tol, double abs_tol,
diff --git a/stan/math/rev/functor/integrate_ode_adams.hpp b/stan/math/rev/functor/integrate_ode_adams.hpp
index 835413f6e1e..fc83e15521e 100644
--- a/stan/math/rev/functor/integrate_ode_adams.hpp
+++ b/stan/math/rev/functor/integrate_ode_adams.hpp
@@ -9,24 +9,24 @@
 namespace stan {
 namespace math {
 
-  /*template <typename F, typename T_initial, typename T_param, typename T_t0,
-          typename T_ts>
+/*template <typename F, typename T_initial, typename T_param, typename T_t0,
+        typename T_ts>
 std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>>
 integrate_ode_adams(const F& f, const std::vector<T_initial>& y0,
-                    const T_t0& t0, const std::vector<T_ts>& ts,
-                    const std::vector<T_param>& theta,
-                    const std::vector<double>& x, const std::vector<int>& x_int,
-                    std::ostream* msgs = nullptr,
-                    double relative_tolerance = 1e-10,
-                    double absolute_tolerance = 1e-10,
-                    long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
-  stan::math::cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts,
-                                std::vector<T_param>, std::vector<double>,
-                                std::vector<int>>
-      integrator(f, y0, t0, ts, theta, x, x_int, msgs, relative_tolerance,
-                 absolute_tolerance, max_num_steps);
-  return integrator.integrate();
-  }*/
+                  const T_t0& t0, const std::vector<T_ts>& ts,
+                  const std::vector<T_param>& theta,
+                  const std::vector<double>& x, const std::vector<int>& x_int,
+                  std::ostream* msgs = nullptr,
+                  double relative_tolerance = 1e-10,
+                  double absolute_tolerance = 1e-10,
+                  long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
+stan::math::cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts,
+                              std::vector<T_param>, std::vector<double>,
+                              std::vector<int>>
+    integrator(f, y0, t0, ts, theta, x, x_int, msgs, relative_tolerance,
+               absolute_tolerance, max_num_steps);
+return integrator.integrate();
+}*/
 
 }  // namespace math
 }  // namespace stan
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 1082b8a49b6..e6336429d62 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -99,9 +99,11 @@ ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
             const T_t0& t0, const std::vector<T_ts>& ts,
             double relative_tolerance, double absolute_tolerance,
             long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
-  auto integrator =
-    new stan::math::cvodes_integrator_vari<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...>
-    (f, y0, t0, ts, relative_tolerance, absolute_tolerance, max_num_steps, msgs, args...);
+  auto integrator
+      = new stan::math::cvodes_integrator_vari<CV_BDF, F, T_initial, T_t0, T_ts,
+                                               T_Args...>(
+          f, y0, t0, ts, relative_tolerance, absolute_tolerance, max_num_steps,
+          msgs, args...);
 
   return (*integrator)();
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index 8e48ec8acbf..500d7b02f56 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -128,9 +128,9 @@ TEST(StanMathOde_ode_bdf_tol, std_vector_arg) {
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0.0;
-  std::vector<double> ts = { 1.1 };
+  std::vector<double> ts = {1.1};
 
-  std::vector<var> a = { 1.5 };
+  std::vector<var> a = {1.5};
 
   var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
                                        nullptr, a)[0][0];

From c719ec52bde9bd1d58374ae7bd5926d0efff581e Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Thu, 21 May 2020 14:01:24 -0400
Subject: [PATCH 116/189] integrate_ode_bdf tests mostly working now (Issue
 #1887)

---
 stan/math/prim/fun/value_of.hpp               |   2 +-
 stan/math/rev/functor/cvodes_integrator.hpp   | 360 ++++++++++--------
 .../functor/integrate_ode_bdf_rev_test.cpp    |  15 +-
 .../math/rev/functor/ode_bdf_rev_test.cpp     |  27 ++
 .../unit/math/rev/functor/util_cvodes_bdf.hpp |   6 +
 5 files changed, 245 insertions(+), 165 deletions(-)

diff --git a/stan/math/prim/fun/value_of.hpp b/stan/math/prim/fun/value_of.hpp
index 54e954633dd..9d514b15c3a 100644
--- a/stan/math/prim/fun/value_of.hpp
+++ b/stan/math/prim/fun/value_of.hpp
@@ -107,7 +107,7 @@ inline Vec value_of(Vec&& x) {
 template <typename EigMat, require_eigen_t<EigMat>* = nullptr,
           require_not_vt_double_or_int<EigMat>* = nullptr>
 inline auto value_of(const EigMat& M) {
-  return M.unaryExpr([](const auto& scal) { return value_of(scal); });
+  return M.unaryExpr([](const auto& scal) { return value_of(scal); }).eval();
 }
 
 /**
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index a9c716b1a2e..88449d678a4 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -18,12 +18,12 @@ namespace stan {
 namespace math {
 
 template <typename T_Return>
-std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> build_varis(
+inline std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> build_varis(
     vari* ode_vari, vari**& non_chaining_varis,
     const std::vector<Eigen::VectorXd>& y);
 
 template <>
-std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> build_varis<var>(
+inline std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> build_varis<var>(
     vari* ode_vari, vari**& non_chaining_varis,
     const std::vector<Eigen::VectorXd>& y) {
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> y_return(y.size());
@@ -37,26 +37,15 @@ std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> build_varis<var>(
   non_chaining_varis
       = ChainableStack::instance_->memalloc_.alloc_array<vari*>(y.size() * N);
 
-  for (size_t i = 0; i < y.size(); i++) {
+  for (size_t i = 0; i < y.size(); ++i) {
     for (size_t j = 0; j < N; j++) {
-      // The special vari that will handle the adjoint solve corresponds to
-      // the output y[y.size() - 1][N - 1]
-      /*if (i == y.size() - 1 && j == N - 1)
-        continue;*/
-
-      // non_chaining_varis[i * N + j] corresponds to the vari attached to
-      // the ode output at time t[i] and state j
       non_chaining_varis[i * N + j] = new vari(y[i][j], false);
     }
   }
 
-  for (size_t i = 0; i < y.size(); i++) {
+  for (size_t i = 0; i < y.size(); ++i) {
     y_return[i].resize(N);
     for (size_t j = 0; j < N; j++)
-      // Inject our special vari at y[y.size() - 1][N - 1]
-      /*if (i == y.size() - 1 && j == N - 1)
-        y_return[i][j] = var(ode_vari);
-        else*/
       y_return[i][j] = var(non_chaining_varis[i * N + j]);
   }
 
@@ -68,12 +57,75 @@ std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> build_varis<var>(
  * no autodiff to handle here).
  */
 template <>
-std::vector<Eigen::VectorXd> build_varis<double>(
+inline std::vector<Eigen::VectorXd> build_varis<double>(
     vari* ode_vari, vari**& non_chaining_varis,
     const std::vector<Eigen::VectorXd>& y) {
   return y;
 }
 
+template <int Lmm, typename F, typename T_y0, typename T_t0, typename T_ts,
+          typename... T_Args>
+class cvodes_integrator_vari;
+
+template <int Lmm, typename F, typename T_y0, typename T_t0, typename T_ts,
+          typename... T_Args>
+class cvodes_integrator_memory : public chainable_alloc {
+  const size_t N_;
+  const F f_;
+  const Eigen::Matrix<T_y0, Eigen::Dynamic, 1> y0_;
+  const T_t0 t0_;
+  const std::vector<T_ts> ts_;
+  std::tuple<T_Args...> args_tuple_;
+  std::tuple<decltype(value_of(T_Args()))...> value_of_args_tuple_;
+  std::vector<Eigen::VectorXd> y_;
+  void* cvodes_mem_;
+  Eigen::VectorXd state;
+  N_Vector nv_state_;
+  SUNMatrix A_;
+  SUNLinearSolver LS_;
+
+  cvodes_integrator_memory(const F& f,
+			   const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
+			   const T_t0& t0, const std::vector<T_ts>& ts,
+			   const T_Args&... args) :
+    N_(y0.size()),
+    f_(f),
+    y0_(y0),
+    t0_(t0),
+    ts_(ts),
+    args_tuple_(std::make_tuple(args...)),
+    value_of_args_tuple_(std::make_tuple(value_of(args)...)),
+    y_(ts_.size()),
+    cvodes_mem_(nullptr),
+    state(value_of(y0)) {
+    if(N_ > 0) {
+      nv_state_ = N_VMake_Serial(N_, state.data());
+      A_ = SUNDenseMatrix(N_, N_);
+      LS_ = SUNDenseLinearSolver(nv_state_, A_);
+
+      cvodes_mem_ = CVodeCreate(Lmm);
+      if (cvodes_mem_ == nullptr) {
+	throw std::runtime_error("CVodeCreate failed to allocate memory");
+      }
+    }
+  }
+
+  ~cvodes_integrator_memory() {
+    if(N_ > 0) {
+      SUNLinSolFree(LS_);
+      SUNMatDestroy(A_);
+
+      N_VDestroy_Serial(nv_state_);
+
+      if(cvodes_mem_) {
+	CVodeFree(&cvodes_mem_);
+      }
+    }
+  }
+
+  friend class cvodes_integrator_vari<Lmm, F, T_y0, T_t0, T_ts, T_Args...>;
+};
+  
 /**
  * Integrator interface for CVODES' ODE solvers (Adams & BDF
  * methods).
@@ -87,31 +139,21 @@ std::vector<Eigen::VectorXd> build_varis<double>(
  */
 template <int Lmm, typename F, typename T_y0, typename T_t0, typename T_ts,
           typename... T_Args>
-class cvodes_integrator_vari : public vari, public chainable_alloc {
+class cvodes_integrator_vari : public vari {
   using T_Return = return_type_t<T_y0, T_t0, T_ts, T_Args...>;
 
-  const F f_;
-  const Eigen::Matrix<T_y0, Eigen::Dynamic, 1> y0_;
-  const T_t0 t0_;
-  const std::vector<T_ts> ts_;
-  std::tuple<T_Args...> args_tuple_;
-  std::tuple<decltype(value_of(T_Args()))...> value_of_args_tuple_;
   const size_t N_;
+  bool returned_;
   std::ostream* msgs_;
   double relative_tolerance_;
   double absolute_tolerance_;
   long int max_num_steps_;
 
-  std::vector<Eigen::VectorXd> y_;
-
   const size_t t0_vars_;
   const size_t ts_vars_;
   const size_t y0_vars_;
   const size_t args_vars_;
 
-  SUNMatrix A_;
-  SUNLinearSolver LS_;
-  void* cvodes_mem_;
   vari** non_chaining_varis_;
 
   vari** t0_varis_;
@@ -119,6 +161,8 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
   vari** y0_varis_;
   vari** args_varis_;
 
+  cvodes_integrator_memory<Lmm, F, T_y0, T_t0, T_ts, T_Args...>* memory;
+
   /**
    * Implements the function of type CVRhsFn which is the user-defined
    * ODE RHS passed to CVODES.
@@ -190,8 +234,8 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
     const Eigen::VectorXd y_vec = Eigen::Map<const Eigen::VectorXd>(y, N_);
 
     Eigen::VectorXd dy_dt_vec
-        = apply([&](auto&&... args) { return f_(t, y_vec, msgs_, args...); },
-                value_of_args_tuple_);
+        = apply([&](auto&&... args) { return memory->f_(t, y_vec, msgs_, args...); },
+                memory->value_of_args_tuple_);
 
     check_size_match("cvodes_integrator::rhs", "dy_dt", dy_dt_vec.size(),
                      "states", N_);
@@ -220,11 +264,11 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
 
     Eigen::Matrix<var, Eigen::Dynamic, 1> y_vars(y_vec.size());
     for (size_t i = 0; i < y_vars.size(); ++i)
-      y_vars(i) = new vari(value_of(y_vec(i)));
+      y_vars(i) = new vari(y_vec(i));
 
     Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars
-        = apply([&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
-                value_of_args_tuple_);
+        = apply([&](auto&&... args) { return memory->f_(t, y_vars, msgs_, args...); },
+                memory->value_of_args_tuple_);
 
     check_size_match("coupled_ode_system1", "dy_dt", f_y_t_vars.size(),
                      "states", N_);
@@ -253,20 +297,20 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
   void quad_rhs_adj(double t, N_Vector y, N_Vector yB, N_Vector qBdot) const {
     Eigen::VectorXd y_vec = Eigen::Map<Eigen::VectorXd>(NV_DATA_S(y), N_);
     Eigen::Map<Eigen::VectorXd> lambda(NV_DATA_S(yB), N_);
-    Eigen::Map<Eigen::VectorXd> mu_dot(NV_DATA_S(qBdot), N_);
-    mu_dot = Eigen::VectorXd::Zero(N_);
+    Eigen::Map<Eigen::VectorXd> mu_dot(NV_DATA_S(qBdot), args_vars_);
+    mu_dot = Eigen::VectorXd::Zero(args_vars_);
 
     nested_rev_autodiff nested;
 
     auto local_args_tuple = apply(
-        [&](auto&&... args) {
+				  [&](auto&&... args) {
           return std::tuple<decltype(deep_copy_vars(args))...>(
               deep_copy_vars(args)...);
         },
-        args_tuple_);
+        memory->args_tuple_);
 
     Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars
-        = apply([&](auto&&... args) { return f_(t, y_vec, msgs_, args...); },
+        = apply([&](auto&&... args) { return memory->f_(t, y_vec, msgs_, args...); },
                 local_args_tuple);
 
     check_size_match("coupled_ode_system2", "dy_dt", f_y_t_vars.size(),
@@ -291,8 +335,8 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
     Eigen::MatrixXd Jfy;
 
     auto f_wrapped = [&](const Eigen::Matrix<var, Eigen::Dynamic, 1>& y) {
-      return apply([&](auto&&... args) { return f_(t, y, msgs_, args...); },
-                   value_of_args_tuple_);
+      return apply([&](auto&&... args) { return memory->f_(t, y, msgs_, args...); },
+                   memory->value_of_args_tuple_);
     };
 
     jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(NV_DATA_S(y), N_), fy,
@@ -318,8 +362,8 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
     Eigen::MatrixXd Jfy;
 
     auto f_wrapped = [&](const Eigen::Matrix<var, Eigen::Dynamic, 1>& y) {
-      return apply([&](auto&&... args) { return f_(t, y, msgs_, args...); },
-                   value_of_args_tuple_);
+      return apply([&](auto&&... args) { return memory->f_(t, y, msgs_, args...); },
+                   memory->value_of_args_tuple_);
     };
 
     jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(NV_DATA_S(y), N_), fy,
@@ -359,21 +403,16 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
                          long int max_num_steps, std::ostream* msgs,
                          const T_Args&... args)
       : vari(NOT_A_NUMBER),
-        f_(f),
-        y0_(y0),
-        t0_(t0),
-        ts_(ts),
-        args_tuple_(args...),
-        value_of_args_tuple_(value_of(args)...),
         N_(y0.size()),
+	returned_(false),
+	memory(NULL),
         msgs_(msgs),
         relative_tolerance_(relative_tolerance),
         absolute_tolerance_(absolute_tolerance),
         max_num_steps_(max_num_steps),
-        y_(ts_.size()),
-        t0_vars_(count_vars(t0_)),
-        ts_vars_(count_vars(ts_)),
-        y0_vars_(count_vars(y0_)),
+        t0_vars_(count_vars(t0)),
+        ts_vars_(count_vars(ts)),
+        y0_vars_(count_vars(y0)),
         args_vars_(count_vars(args...)),
         t0_varis_(
             ChainableStack::instance_->memalloc_.alloc_array<vari*>(t0_vars_)),
@@ -385,14 +424,17 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
             args_vars_)) {
     const char* fun = "cvodes_integrator::integrate";
 
+    memory = new cvodes_integrator_memory
+      <Lmm, F, T_y0, T_t0, T_ts, T_Args...>(f, y0, t0, ts, args...);
+  
     save_varis(t0_varis_, t0);
     save_varis(ts_varis_, ts);
     save_varis(y0_varis_, y0);
     save_varis(args_varis_, args...);
 
-    check_finite(fun, "initial state", y0_);
-    check_finite(fun, "initial time", t0_);
-    check_finite(fun, "times", ts_);
+    check_finite(fun, "initial state", y0);
+    check_finite(fun, "initial time", t0);
+    check_finite(fun, "times", ts);
 
     // Code from: https://stackoverflow.com/a/17340003 . Should probably do
     // something better
@@ -401,27 +443,18 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
           std::vector<int> unused_temp{
               0, (check_finite(fun, "ode parameters and data", args), 0)...};
         },
-        args_tuple_);
+        memory->args_tuple_);
 
-    check_nonzero_size(fun, "times", ts_);
-    check_nonzero_size(fun, "initial state", y0_);
-    check_ordered(fun, "times", ts_);
-    check_less(fun, "initial time", t0_, ts_[0]);
+    check_nonzero_size(fun, "times", ts);
+    check_nonzero_size(fun, "initial state", y0);
+    check_ordered(fun, "times", ts);
+    check_less(fun, "initial time", t0, ts[0]);
     check_positive_finite(fun, "relative_tolerance", relative_tolerance_);
     check_positive_finite(fun, "absolute_tolerance", absolute_tolerance_);
     check_positive(fun, "max_num_steps", max_num_steps_);
   }
 
   ~cvodes_integrator_vari() {
-    std::cout << "FREEEEEEEEEEEEEEEEEEEEEEEDOM!" << std::endl;
-    std::cout << "FREEEEEEEEEEEEEEEEEEEEEEEDOM!" << std::endl;
-    std::cout << "FREEEEEEEEEEEEEEEEEEEEEEEDOM!" << std::endl;
-    std::cout << "FREEEEEEEEEEEEEEEEEEEEEEEDOM!" << std::endl;
-
-    // At some point in the future I should free memory
-    SUNLinSolFree(LS_);
-    SUNMatDestroy(A_);
-    CVodeFree(&cvodes_mem_);
   }
 
   /**
@@ -433,86 +466,77 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
    *   solution time (excluding the initial state)
    */
   std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> operator()() {
-    Eigen::VectorXd state = value_of(y0_);
-    N_Vector nv_state = N_VMake_Serial(state.size(), state.data());
-
-    A_ = SUNDenseMatrix(N_, N_);
-    LS_ = SUNDenseLinearSolver(nv_state, A_);
-
-    const double t0_dbl = value_of(t0_);
-    const std::vector<double> ts_dbl = value_of(ts_);
-
-    cvodes_mem_ = CVodeCreate(Lmm);
-    if (cvodes_mem_ == nullptr) {
-      throw std::runtime_error("CVodeCreate failed to allocate memory");
+    const double t0_dbl = value_of(memory->t0_);
+    const std::vector<double> ts_dbl = value_of(memory->ts_);
+
+    check_flag_sundials(CVodeInit(memory->cvodes_mem_, &cvodes_integrator_vari::cv_rhs, t0_dbl,
+				  memory->nv_state_),
+			"CVodeInit");
+
+    // Assign pointer to this as user data
+    check_flag_sundials(
+			CVodeSetUserData(memory->cvodes_mem_, reinterpret_cast<void*>(this)),
+			"CVodeSetUserData");
+
+    cvodes_set_options(memory->cvodes_mem_, relative_tolerance_, absolute_tolerance_,
+		       max_num_steps_);
+
+    // for the stiff solvers we need to reserve additional memory
+    // and provide a Jacobian function call. new API since 3.0.0:
+    // create matrix object and linear solver object; resource
+    // (de-)allocation is handled in the cvodes_ode_data
+    check_flag_sundials(CVodeSetLinearSolver(memory->cvodes_mem_, memory->LS_, memory->A_),
+			"CVodeSetLinearSolver");
+
+    check_flag_sundials(
+			CVodeSetJacFn(memory->cvodes_mem_,
+				      &cvodes_integrator_vari::cv_jacobian_states),
+			"CVodeSetJacFn");
+
+    // initialize forward sensitivity system of CVODES as needed
+    if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ > 0) {
+      check_flag_sundials(CVodeAdjInit(memory->cvodes_mem_, 25, CV_HERMITE),
+			  "CVodeAdjInit");
     }
 
-    try {
-      check_flag_sundials(
-          CVodeInit(cvodes_mem_, &cvodes_integrator_vari::cv_rhs, t0_dbl,
-                    nv_state),
-          "CVodeInit");
-
-      // Assign pointer to this as user data
-      check_flag_sundials(
-          CVodeSetUserData(cvodes_mem_, reinterpret_cast<void*>(this)),
-          "CVodeSetUserData");
-
-      cvodes_set_options(cvodes_mem_, relative_tolerance_, absolute_tolerance_,
-                         max_num_steps_);
-
-      // for the stiff solvers we need to reserve additional memory
-      // and provide a Jacobian function call. new API since 3.0.0:
-      // create matrix object and linear solver object; resource
-      // (de-)allocation is handled in the cvodes_ode_data
-      check_flag_sundials(CVodeSetLinearSolver(cvodes_mem_, LS_, A_),
-                          "CVodeSetLinearSolver");
-
-      check_flag_sundials(
-          CVodeSetJacFn(cvodes_mem_,
-                        &cvodes_integrator_vari::cv_jacobian_states),
-          "CVodeSetJacFn");
-
-      // initialize forward sensitivity system of CVODES as needed
-      if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ > 0) {
-        check_flag_sundials(CVodeAdjInit(cvodes_mem_, 25, CV_HERMITE),
-                            "CVodeAdjInit");
+    double t_init = t0_dbl;
+    for (size_t n = 0; n < ts_dbl.size(); ++n) {
+      double t_final = ts_dbl[n];
+
+      if (t_final != t_init) {
+	if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ > 0) {
+	  int ncheck;
+	  check_flag_sundials(CVodeF(memory->cvodes_mem_, t_final, memory->nv_state_, &t_init,
+				     CV_NORMAL, &ncheck),
+			      "CVodeF");
+	} else {
+	  check_flag_sundials(
+			      CVode(memory->cvodes_mem_, t_final, memory->nv_state_, &t_init, CV_NORMAL),
+			      "CVode");
+	}
       }
 
-      double t_init = t0_dbl;
-      for (size_t n = 0; n < ts_.size(); ++n) {
-        double t_final = ts_dbl[n];
-
-        if (t_final != t_init) {
-          if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ > 0) {
-            int ncheck;
-            check_flag_sundials(CVodeF(cvodes_mem_, t_final, nv_state, &t_init,
-                                       CV_NORMAL, &ncheck),
-                                "CVodeF");
-          } else {
-            check_flag_sundials(
-                CVode(cvodes_mem_, t_final, nv_state, &t_init, CV_NORMAL),
-                "CVode");
-          }
-        }
-
-        y_[n] = state;
+      memory->y_[n] = memory->state;
 
-        t_init = t_final;
-      }
-    } catch (const std::exception& e) {
-      N_VDestroy_Serial(nv_state);
-      throw;
+      t_init = t_final;
     }
 
-    N_VDestroy_Serial(nv_state);
-
-    return build_varis<T_Return>(this, non_chaining_varis_, y_);
+    returned_ = true;
+    return build_varis<T_Return>(this, non_chaining_varis_, memory->y_);
   }
 
   virtual void chain() {
     // std::cout << "chain" << std::endl; <-- Good way to verify it's only
     //  being called once
+    if(memory == NULL)
+      return;
+
+    if(memory->cvodes_mem_ == NULL)
+      return;
+    
+    if(returned_ == false)
+      return;
+
     if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ == 0) {
       return;
     }
@@ -532,96 +556,112 @@ class cvodes_integrator_vari : public vari, public chainable_alloc {
       int indexB;
 
       // This is all boilerplate CVODES setting up the adjoint ODE to solve
-      check_flag_sundials(CVodeCreateB(cvodes_mem_, Lmm, &indexB),
+      check_flag_sundials(CVodeCreateB(memory->cvodes_mem_, Lmm, &indexB),
                           "CVodeCreateB");
 
       check_flag_sundials(
-          CVodeSetUserDataB(cvodes_mem_, indexB, reinterpret_cast<void*>(this)),
+          CVodeSetUserDataB(memory->cvodes_mem_, indexB, reinterpret_cast<void*>(this)),
           "CVodeSetUserDataB");
 
       // The ode_rhs_adj_sense functions passed in here cause problems with
       // the autodiff stack (they can cause reallocations of the internal
       // vectors and cause segfaults)
-      check_flag_sundials(CVodeInitB(cvodes_mem_, indexB,
+      check_flag_sundials(CVodeInitB(memory->cvodes_mem_, indexB,
                                      &cvodes_integrator_vari::cv_rhs_adj_sens,
-                                     value_of(ts_.back()), nv_state_sens),
+                                     value_of(memory->ts_.back()), nv_state_sens),
                           "CVodeInitB");
 
       check_flag_sundials(
-          CVodeSStolerancesB(cvodes_mem_, indexB, relative_tolerance_,
+          CVodeSStolerancesB(memory->cvodes_mem_, indexB, relative_tolerance_,
                              absolute_tolerance_),
           "CVodeSStolerancesB");
 
-      check_flag_sundials(CVodeSetLinearSolverB(cvodes_mem_, indexB, LSB_, AB_),
+      check_flag_sundials(CVodeSetLinearSolverB(memory->cvodes_mem_, indexB, LSB_, AB_),
                           "CVodeSetLinearSolverB");
 
       // The same autodiff issue that applies to ode_rhs_adj_sense applies
       // here
       check_flag_sundials(
-          CVodeSetJacFnB(cvodes_mem_, indexB,
+          CVodeSetJacFnB(memory->cvodes_mem_, indexB,
                          &cvodes_integrator_vari::cv_jacobian_adj),
           "CVodeSetJacFnB");
 
       // Allocate space for backwards quadrature
       if (args_vars_ > 0) {
         check_flag_sundials(
-            CVodeQuadInitB(cvodes_mem_, indexB,
+            CVodeQuadInitB(memory->cvodes_mem_, indexB,
                            &cvodes_integrator_vari::cv_quad_rhs_adj, nv_quad),
             "CVodeQuadInitB");
 
         check_flag_sundials(
-            CVodeQuadSStolerancesB(cvodes_mem_, indexB, relative_tolerance_,
+            CVodeQuadSStolerancesB(memory->cvodes_mem_, indexB, relative_tolerance_,
                                    absolute_tolerance_),
             "CVodeQuadSStolerancesB");
 
-        check_flag_sundials(CVodeSetQuadErrConB(cvodes_mem_, indexB, SUNTRUE),
+        check_flag_sundials(CVodeSetQuadErrConB(memory->cvodes_mem_, indexB, SUNTRUE),
                             "CVodeSetQuadErrConB");
       }
 
       // At every time step, collect the adjoints from the output
       // variables and re-initialize the solver
-      double t_init = value_of(ts_.back());
-      for (int i = ts_.size() - 1; i >= 0; --i) {
+      double t_init = value_of(memory->ts_.back());
+      for (int i = memory->ts_.size() - 1; i >= 0; --i) {
         // Take in the adjoints from all the output variables at this point
         // in time
+	Eigen::VectorXd step_sens = Eigen::VectorXd::Zero(N_);
         for (int j = 0; j < N_; j++) {
+	  //std::cout << "i: " << i << ", j: " << j << std::endl;
           state_sens(j) += non_chaining_varis_[i * N_ + j]->adj_;
+          step_sens(j) += non_chaining_varis_[i * N_ + j]->adj_;
         }
 
         if (ts_vars_ > 0 && i >= 0) {
           ts_varis_[i]->adj_ += apply(
               [&](auto&&... args) {
-                return state_sens.dot(f_(t_init, y_[i], msgs_, args...));
+		double adj = step_sens.dot(memory->f_(t_init, memory->y_[i], msgs_, args...));
+		//std::cout << "adj: " << adj << ", i: " << i << std::endl;
+                return adj;
               },
-              value_of_args_tuple_);
+              memory->value_of_args_tuple_);
         }
 
-        double t_final = value_of((i > 0) ? ts_[i - 1] : t0_);
+        double t_final = value_of((i > 0) ? memory->ts_[i - 1] : memory->t0_);
         if (t_final != t_init) {
           check_flag_sundials(
-              CVodeReInitB(cvodes_mem_, indexB, t_init, nv_state_sens),
+              CVodeReInitB(memory->cvodes_mem_, indexB, t_init, nv_state_sens),
               "CVodeReInitB");
 
-          check_flag_sundials(CVodeB(cvodes_mem_, t_final, CV_NORMAL),
+	  if(args_vars_ > 0) {
+	    check_flag_sundials(CVodeQuadReInitB(memory->cvodes_mem_, indexB, nv_quad),
+	    			"CVodeQuadReInitB");
+	  }
+
+          check_flag_sundials(CVodeB(memory->cvodes_mem_, t_final, CV_NORMAL),
                               "CVodeB");
 
-          check_flag_sundials(
-              CVodeGetB(cvodes_mem_, indexB, &t_init, nv_state_sens),
-              "CVodeGetB");
+	  check_flag_sundials(
+	  		      CVodeGetB(memory->cvodes_mem_, indexB, &t_init, nv_state_sens),
+	  		      "CVodeGetB");
+
+	  if(args_vars_ > 0) {
+	    check_flag_sundials(CVodeGetQuadB(memory->cvodes_mem_, indexB, &t_init, nv_quad),
+	    		"CVodeGetQuadB");
+	  }
         }
       }
 
       if (t0_vars_ > 0) {
+	Eigen::VectorXd y0d = value_of(memory->y0_);
         t0_varis_[0]->adj_ += apply(
             [&](auto&&... args) {
-              return -state_sens.dot(f_(t_init, value_of(y0_), msgs_, args...));
+              return -state_sens.dot(memory->f_(t_init, y0d, msgs_, args...));
             },
-            value_of_args_tuple_);
+            memory->value_of_args_tuple_);
       }
 
       if (args_vars_ > 0) {
         check_flag_sundials(
-            CVodeGetQuadB(cvodes_mem_, indexB, &t_init, nv_quad),
+            CVodeGetQuadB(memory->cvodes_mem_, indexB, &t_init, nv_quad),
             "CVodeGetQuadB");
       }
 
diff --git a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
index df8452b7b2c..9ab3e748a30 100644
--- a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
@@ -26,6 +26,8 @@ void sho_value_test(F harm_osc, std::vector<double>& y0, double t0,
 
   EXPECT_NEAR(-0.421907, ode_res_vd[99][0].val(), 1e-5);
   EXPECT_NEAR(0.246407, ode_res_vd[99][1].val(), 1e-5);
+
+  stan::math::recover_memory();
 }
 
 void sho_finite_diff_test(double t0) {
@@ -159,7 +161,7 @@ TEST(StanAgradRevOde_integrate_ode_bdf, lorenz_finite_diff) {
   for (int i = 0; i < 100; i++)
     ts.push_back(0.1 * (i + 1));
 
-  test_ode_cvode(lorenz, t0, ts, y0, theta, x, x_int, 1e-8, 1e-1);
+  test_ode_cvode(lorenz, t0, ts, y0, theta, x, x_int, 1e-6, 1e-1);
 }
 
 TEST(StanAgradRevOde_integrate_ode_bdf, time_steps_as_param) {
@@ -202,6 +204,8 @@ TEST(StanAgradRevOde_integrate_ode_bdf, time_steps_as_param) {
   test_val();
   res = integrate_ode_bdf(ode, y0v, t0v, ts, thetav, x, x_int);
   test_val();
+
+  stan::math::recover_memory();
 }
 
 TEST(StanAgradRevOde_integrate_ode_bdf, time_steps_as_param_AD) {
@@ -234,13 +238,14 @@ TEST(StanAgradRevOde_integrate_ode_bdf, time_steps_as_param_AD) {
       std::vector<double> res_d = value_of(res[i]);
       for (auto j = 0; j < ns; ++j) {
         g.clear();
-        res[i][j].grad(ts, g);
+        res[i][j].grad();
         for (auto k = 0; k < nt; ++k) {
           if (k != i) {
-            EXPECT_FLOAT_EQ(g[k], 0.0);
+	    //std::cout << "setup: i = " << i << ", j = " << j << ", k = " << k << std::endl;
+            EXPECT_FLOAT_EQ(ts[k].adj(), 0.0);
           } else {
             std::vector<double> y0(res_d.begin(), res_d.begin() + ns);
-            EXPECT_FLOAT_EQ(g[k],
+            EXPECT_FLOAT_EQ(ts[k].adj(),
                             ode(ts[i].val(), y0, msgs, theta, x, x_int)[j]);
           }
         }
@@ -305,4 +310,6 @@ TEST(StanAgradRevOde_integrate_ode_bdf, t0_as_param_AD) {
   res = integrate_ode_bdf(ode, y0v, t0v, ts, thetav, x, x_int, nullptr, 1e-10,
                           1e-10, 1e6);
   test_ad();
+  stan::math::recover_memory();
 }
+
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index 500d7b02f56..bbcad7bed79 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -123,6 +123,33 @@ TEST(StanMathOde_ode_bdf_tol, scalar_arg) {
   EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
 }
 
+TEST(StanMathOde_ode_bdf_tol, scalar_arg_multi_time) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  var a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output =
+    stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+			    nullptr, a);
+
+
+  output[0](0).grad();
+
+  EXPECT_FLOAT_EQ(output[0](0).val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(a.adj(), -0.04352005542);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1](0).grad();
+
+  EXPECT_FLOAT_EQ(output[1](0).val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+}
+
 TEST(StanMathOde_ode_bdf_tol, std_vector_arg) {
   using stan::math::var;
 
diff --git a/test/unit/math/rev/functor/util_cvodes_bdf.hpp b/test/unit/math/rev/functor/util_cvodes_bdf.hpp
index 2810e376acc..9bd6e7f4453 100644
--- a/test/unit/math/rev/functor/util_cvodes_bdf.hpp
+++ b/test/unit/math/rev/functor/util_cvodes_bdf.hpp
@@ -118,6 +118,8 @@ void test_ode_finite_diff_dv(const F& f, const double& t_in,
       stan::math::set_zero_all_adjoints();
     }
   }
+
+  stan::math::recover_memory();
 }
 
 // test integrate_ode with initial positions as vars and parameters as doubles
@@ -161,6 +163,8 @@ void test_ode_finite_diff_vd(const F& f, const double& t_in,
       stan::math::set_zero_all_adjoints();
     }
   }
+
+  stan::math::recover_memory();
 }
 
 // test integrate_ode with initial positions as vars and parameters as vars
@@ -227,6 +231,8 @@ void test_ode_finite_diff_vv(const F& f, const double& t_in,
       stan::math::set_zero_all_adjoints();
     }
   }
+
+  stan::math::recover_memory();
 }
 
 template <typename F, typename T1, typename T2>

From 94fdd3edb6e7a65015277c2e11bc5e6be620a035 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Thu, 21 May 2020 14:06:58 -0400
Subject: [PATCH 117/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 stan/math/rev/functor/cvodes_integrator.hpp   | 204 +++++++++---------
 .../functor/integrate_ode_bdf_rev_test.cpp    |   4 +-
 .../math/rev/functor/ode_bdf_rev_test.cpp     |   7 +-
 3 files changed, 112 insertions(+), 103 deletions(-)

diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 88449d678a4..a2df7919fa6 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -85,47 +85,47 @@ class cvodes_integrator_memory : public chainable_alloc {
   SUNLinearSolver LS_;
 
   cvodes_integrator_memory(const F& f,
-			   const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
-			   const T_t0& t0, const std::vector<T_ts>& ts,
-			   const T_Args&... args) :
-    N_(y0.size()),
-    f_(f),
-    y0_(y0),
-    t0_(t0),
-    ts_(ts),
-    args_tuple_(std::make_tuple(args...)),
-    value_of_args_tuple_(std::make_tuple(value_of(args)...)),
-    y_(ts_.size()),
-    cvodes_mem_(nullptr),
-    state(value_of(y0)) {
-    if(N_ > 0) {
+                           const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
+                           const T_t0& t0, const std::vector<T_ts>& ts,
+                           const T_Args&... args)
+      : N_(y0.size()),
+        f_(f),
+        y0_(y0),
+        t0_(t0),
+        ts_(ts),
+        args_tuple_(std::make_tuple(args...)),
+        value_of_args_tuple_(std::make_tuple(value_of(args)...)),
+        y_(ts_.size()),
+        cvodes_mem_(nullptr),
+        state(value_of(y0)) {
+    if (N_ > 0) {
       nv_state_ = N_VMake_Serial(N_, state.data());
       A_ = SUNDenseMatrix(N_, N_);
       LS_ = SUNDenseLinearSolver(nv_state_, A_);
 
       cvodes_mem_ = CVodeCreate(Lmm);
       if (cvodes_mem_ == nullptr) {
-	throw std::runtime_error("CVodeCreate failed to allocate memory");
+        throw std::runtime_error("CVodeCreate failed to allocate memory");
       }
     }
   }
 
   ~cvodes_integrator_memory() {
-    if(N_ > 0) {
+    if (N_ > 0) {
       SUNLinSolFree(LS_);
       SUNMatDestroy(A_);
 
       N_VDestroy_Serial(nv_state_);
 
-      if(cvodes_mem_) {
-	CVodeFree(&cvodes_mem_);
+      if (cvodes_mem_) {
+        CVodeFree(&cvodes_mem_);
       }
     }
   }
 
   friend class cvodes_integrator_vari<Lmm, F, T_y0, T_t0, T_ts, T_Args...>;
 };
-  
+
 /**
  * Integrator interface for CVODES' ODE solvers (Adams & BDF
  * methods).
@@ -233,9 +233,9 @@ class cvodes_integrator_vari : public vari {
   inline void rhs(double t, const double y[], double dy_dt[]) const {
     const Eigen::VectorXd y_vec = Eigen::Map<const Eigen::VectorXd>(y, N_);
 
-    Eigen::VectorXd dy_dt_vec
-        = apply([&](auto&&... args) { return memory->f_(t, y_vec, msgs_, args...); },
-                memory->value_of_args_tuple_);
+    Eigen::VectorXd dy_dt_vec = apply(
+        [&](auto&&... args) { return memory->f_(t, y_vec, msgs_, args...); },
+        memory->value_of_args_tuple_);
 
     check_size_match("cvodes_integrator::rhs", "dy_dt", dy_dt_vec.size(),
                      "states", N_);
@@ -266,9 +266,9 @@ class cvodes_integrator_vari : public vari {
     for (size_t i = 0; i < y_vars.size(); ++i)
       y_vars(i) = new vari(y_vec(i));
 
-    Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars
-        = apply([&](auto&&... args) { return memory->f_(t, y_vars, msgs_, args...); },
-                memory->value_of_args_tuple_);
+    Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars = apply(
+        [&](auto&&... args) { return memory->f_(t, y_vars, msgs_, args...); },
+        memory->value_of_args_tuple_);
 
     check_size_match("coupled_ode_system1", "dy_dt", f_y_t_vars.size(),
                      "states", N_);
@@ -303,15 +303,15 @@ class cvodes_integrator_vari : public vari {
     nested_rev_autodiff nested;
 
     auto local_args_tuple = apply(
-				  [&](auto&&... args) {
+        [&](auto&&... args) {
           return std::tuple<decltype(deep_copy_vars(args))...>(
               deep_copy_vars(args)...);
         },
         memory->args_tuple_);
 
-    Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars
-        = apply([&](auto&&... args) { return memory->f_(t, y_vec, msgs_, args...); },
-                local_args_tuple);
+    Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars = apply(
+        [&](auto&&... args) { return memory->f_(t, y_vec, msgs_, args...); },
+        local_args_tuple);
 
     check_size_match("coupled_ode_system2", "dy_dt", f_y_t_vars.size(),
                      "states", N_);
@@ -335,8 +335,9 @@ class cvodes_integrator_vari : public vari {
     Eigen::MatrixXd Jfy;
 
     auto f_wrapped = [&](const Eigen::Matrix<var, Eigen::Dynamic, 1>& y) {
-      return apply([&](auto&&... args) { return memory->f_(t, y, msgs_, args...); },
-                   memory->value_of_args_tuple_);
+      return apply(
+          [&](auto&&... args) { return memory->f_(t, y, msgs_, args...); },
+          memory->value_of_args_tuple_);
     };
 
     jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(NV_DATA_S(y), N_), fy,
@@ -362,8 +363,9 @@ class cvodes_integrator_vari : public vari {
     Eigen::MatrixXd Jfy;
 
     auto f_wrapped = [&](const Eigen::Matrix<var, Eigen::Dynamic, 1>& y) {
-      return apply([&](auto&&... args) { return memory->f_(t, y, msgs_, args...); },
-                   memory->value_of_args_tuple_);
+      return apply(
+          [&](auto&&... args) { return memory->f_(t, y, msgs_, args...); },
+          memory->value_of_args_tuple_);
     };
 
     jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(NV_DATA_S(y), N_), fy,
@@ -404,8 +406,8 @@ class cvodes_integrator_vari : public vari {
                          const T_Args&... args)
       : vari(NOT_A_NUMBER),
         N_(y0.size()),
-	returned_(false),
-	memory(NULL),
+        returned_(false),
+        memory(NULL),
         msgs_(msgs),
         relative_tolerance_(relative_tolerance),
         absolute_tolerance_(absolute_tolerance),
@@ -424,9 +426,9 @@ class cvodes_integrator_vari : public vari {
             args_vars_)) {
     const char* fun = "cvodes_integrator::integrate";
 
-    memory = new cvodes_integrator_memory
-      <Lmm, F, T_y0, T_t0, T_ts, T_Args...>(f, y0, t0, ts, args...);
-  
+    memory = new cvodes_integrator_memory<Lmm, F, T_y0, T_t0, T_ts, T_Args...>(
+        f, y0, t0, ts, args...);
+
     save_varis(t0_varis_, t0);
     save_varis(ts_varis_, ts);
     save_varis(y0_varis_, y0);
@@ -454,8 +456,7 @@ class cvodes_integrator_vari : public vari {
     check_positive(fun, "max_num_steps", max_num_steps_);
   }
 
-  ~cvodes_integrator_vari() {
-  }
+  ~cvodes_integrator_vari() {}
 
   /**
    * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
@@ -469,34 +470,36 @@ class cvodes_integrator_vari : public vari {
     const double t0_dbl = value_of(memory->t0_);
     const std::vector<double> ts_dbl = value_of(memory->ts_);
 
-    check_flag_sundials(CVodeInit(memory->cvodes_mem_, &cvodes_integrator_vari::cv_rhs, t0_dbl,
-				  memory->nv_state_),
-			"CVodeInit");
+    check_flag_sundials(
+        CVodeInit(memory->cvodes_mem_, &cvodes_integrator_vari::cv_rhs, t0_dbl,
+                  memory->nv_state_),
+        "CVodeInit");
 
     // Assign pointer to this as user data
     check_flag_sundials(
-			CVodeSetUserData(memory->cvodes_mem_, reinterpret_cast<void*>(this)),
-			"CVodeSetUserData");
+        CVodeSetUserData(memory->cvodes_mem_, reinterpret_cast<void*>(this)),
+        "CVodeSetUserData");
 
-    cvodes_set_options(memory->cvodes_mem_, relative_tolerance_, absolute_tolerance_,
-		       max_num_steps_);
+    cvodes_set_options(memory->cvodes_mem_, relative_tolerance_,
+                       absolute_tolerance_, max_num_steps_);
 
     // for the stiff solvers we need to reserve additional memory
     // and provide a Jacobian function call. new API since 3.0.0:
     // create matrix object and linear solver object; resource
     // (de-)allocation is handled in the cvodes_ode_data
-    check_flag_sundials(CVodeSetLinearSolver(memory->cvodes_mem_, memory->LS_, memory->A_),
-			"CVodeSetLinearSolver");
+    check_flag_sundials(
+        CVodeSetLinearSolver(memory->cvodes_mem_, memory->LS_, memory->A_),
+        "CVodeSetLinearSolver");
 
     check_flag_sundials(
-			CVodeSetJacFn(memory->cvodes_mem_,
-				      &cvodes_integrator_vari::cv_jacobian_states),
-			"CVodeSetJacFn");
+        CVodeSetJacFn(memory->cvodes_mem_,
+                      &cvodes_integrator_vari::cv_jacobian_states),
+        "CVodeSetJacFn");
 
     // initialize forward sensitivity system of CVODES as needed
     if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ > 0) {
       check_flag_sundials(CVodeAdjInit(memory->cvodes_mem_, 25, CV_HERMITE),
-			  "CVodeAdjInit");
+                          "CVodeAdjInit");
     }
 
     double t_init = t0_dbl;
@@ -504,16 +507,17 @@ class cvodes_integrator_vari : public vari {
       double t_final = ts_dbl[n];
 
       if (t_final != t_init) {
-	if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ > 0) {
-	  int ncheck;
-	  check_flag_sundials(CVodeF(memory->cvodes_mem_, t_final, memory->nv_state_, &t_init,
-				     CV_NORMAL, &ncheck),
-			      "CVodeF");
-	} else {
-	  check_flag_sundials(
-			      CVode(memory->cvodes_mem_, t_final, memory->nv_state_, &t_init, CV_NORMAL),
-			      "CVode");
-	}
+        if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ > 0) {
+          int ncheck;
+          check_flag_sundials(
+              CVodeF(memory->cvodes_mem_, t_final, memory->nv_state_, &t_init,
+                     CV_NORMAL, &ncheck),
+              "CVodeF");
+        } else {
+          check_flag_sundials(CVode(memory->cvodes_mem_, t_final,
+                                    memory->nv_state_, &t_init, CV_NORMAL),
+                              "CVode");
+        }
       }
 
       memory->y_[n] = memory->state;
@@ -528,13 +532,13 @@ class cvodes_integrator_vari : public vari {
   virtual void chain() {
     // std::cout << "chain" << std::endl; <-- Good way to verify it's only
     //  being called once
-    if(memory == NULL)
+    if (memory == NULL)
       return;
 
-    if(memory->cvodes_mem_ == NULL)
+    if (memory->cvodes_mem_ == NULL)
       return;
-    
-    if(returned_ == false)
+
+    if (returned_ == false)
       return;
 
     if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ == 0) {
@@ -559,25 +563,27 @@ class cvodes_integrator_vari : public vari {
       check_flag_sundials(CVodeCreateB(memory->cvodes_mem_, Lmm, &indexB),
                           "CVodeCreateB");
 
-      check_flag_sundials(
-          CVodeSetUserDataB(memory->cvodes_mem_, indexB, reinterpret_cast<void*>(this)),
-          "CVodeSetUserDataB");
+      check_flag_sundials(CVodeSetUserDataB(memory->cvodes_mem_, indexB,
+                                            reinterpret_cast<void*>(this)),
+                          "CVodeSetUserDataB");
 
       // The ode_rhs_adj_sense functions passed in here cause problems with
       // the autodiff stack (they can cause reallocations of the internal
       // vectors and cause segfaults)
-      check_flag_sundials(CVodeInitB(memory->cvodes_mem_, indexB,
-                                     &cvodes_integrator_vari::cv_rhs_adj_sens,
-                                     value_of(memory->ts_.back()), nv_state_sens),
-                          "CVodeInitB");
+      check_flag_sundials(
+          CVodeInitB(memory->cvodes_mem_, indexB,
+                     &cvodes_integrator_vari::cv_rhs_adj_sens,
+                     value_of(memory->ts_.back()), nv_state_sens),
+          "CVodeInitB");
 
       check_flag_sundials(
           CVodeSStolerancesB(memory->cvodes_mem_, indexB, relative_tolerance_,
                              absolute_tolerance_),
           "CVodeSStolerancesB");
 
-      check_flag_sundials(CVodeSetLinearSolverB(memory->cvodes_mem_, indexB, LSB_, AB_),
-                          "CVodeSetLinearSolverB");
+      check_flag_sundials(
+          CVodeSetLinearSolverB(memory->cvodes_mem_, indexB, LSB_, AB_),
+          "CVodeSetLinearSolverB");
 
       // The same autodiff issue that applies to ode_rhs_adj_sense applies
       // here
@@ -594,12 +600,13 @@ class cvodes_integrator_vari : public vari {
             "CVodeQuadInitB");
 
         check_flag_sundials(
-            CVodeQuadSStolerancesB(memory->cvodes_mem_, indexB, relative_tolerance_,
-                                   absolute_tolerance_),
+            CVodeQuadSStolerancesB(memory->cvodes_mem_, indexB,
+                                   relative_tolerance_, absolute_tolerance_),
             "CVodeQuadSStolerancesB");
 
-        check_flag_sundials(CVodeSetQuadErrConB(memory->cvodes_mem_, indexB, SUNTRUE),
-                            "CVodeSetQuadErrConB");
+        check_flag_sundials(
+            CVodeSetQuadErrConB(memory->cvodes_mem_, indexB, SUNTRUE),
+            "CVodeSetQuadErrConB");
       }
 
       // At every time step, collect the adjoints from the output
@@ -608,9 +615,9 @@ class cvodes_integrator_vari : public vari {
       for (int i = memory->ts_.size() - 1; i >= 0; --i) {
         // Take in the adjoints from all the output variables at this point
         // in time
-	Eigen::VectorXd step_sens = Eigen::VectorXd::Zero(N_);
+        Eigen::VectorXd step_sens = Eigen::VectorXd::Zero(N_);
         for (int j = 0; j < N_; j++) {
-	  //std::cout << "i: " << i << ", j: " << j << std::endl;
+          // std::cout << "i: " << i << ", j: " << j << std::endl;
           state_sens(j) += non_chaining_varis_[i * N_ + j]->adj_;
           step_sens(j) += non_chaining_varis_[i * N_ + j]->adj_;
         }
@@ -618,8 +625,9 @@ class cvodes_integrator_vari : public vari {
         if (ts_vars_ > 0 && i >= 0) {
           ts_varis_[i]->adj_ += apply(
               [&](auto&&... args) {
-		double adj = step_sens.dot(memory->f_(t_init, memory->y_[i], msgs_, args...));
-		//std::cout << "adj: " << adj << ", i: " << i << std::endl;
+                double adj = step_sens.dot(
+                    memory->f_(t_init, memory->y_[i], msgs_, args...));
+                // std::cout << "adj: " << adj << ", i: " << i << std::endl;
                 return adj;
               },
               memory->value_of_args_tuple_);
@@ -631,27 +639,29 @@ class cvodes_integrator_vari : public vari {
               CVodeReInitB(memory->cvodes_mem_, indexB, t_init, nv_state_sens),
               "CVodeReInitB");
 
-	  if(args_vars_ > 0) {
-	    check_flag_sundials(CVodeQuadReInitB(memory->cvodes_mem_, indexB, nv_quad),
-	    			"CVodeQuadReInitB");
-	  }
+          if (args_vars_ > 0) {
+            check_flag_sundials(
+                CVodeQuadReInitB(memory->cvodes_mem_, indexB, nv_quad),
+                "CVodeQuadReInitB");
+          }
 
           check_flag_sundials(CVodeB(memory->cvodes_mem_, t_final, CV_NORMAL),
                               "CVodeB");
 
-	  check_flag_sundials(
-	  		      CVodeGetB(memory->cvodes_mem_, indexB, &t_init, nv_state_sens),
-	  		      "CVodeGetB");
-
-	  if(args_vars_ > 0) {
-	    check_flag_sundials(CVodeGetQuadB(memory->cvodes_mem_, indexB, &t_init, nv_quad),
-	    		"CVodeGetQuadB");
-	  }
+          check_flag_sundials(
+              CVodeGetB(memory->cvodes_mem_, indexB, &t_init, nv_state_sens),
+              "CVodeGetB");
+
+          if (args_vars_ > 0) {
+            check_flag_sundials(
+                CVodeGetQuadB(memory->cvodes_mem_, indexB, &t_init, nv_quad),
+                "CVodeGetQuadB");
+          }
         }
       }
 
       if (t0_vars_ > 0) {
-	Eigen::VectorXd y0d = value_of(memory->y0_);
+        Eigen::VectorXd y0d = value_of(memory->y0_);
         t0_varis_[0]->adj_ += apply(
             [&](auto&&... args) {
               return -state_sens.dot(memory->f_(t_init, y0d, msgs_, args...));
diff --git a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
index 9ab3e748a30..ae034f85076 100644
--- a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
@@ -241,7 +241,8 @@ TEST(StanAgradRevOde_integrate_ode_bdf, time_steps_as_param_AD) {
         res[i][j].grad();
         for (auto k = 0; k < nt; ++k) {
           if (k != i) {
-	    //std::cout << "setup: i = " << i << ", j = " << j << ", k = " << k << std::endl;
+            // std::cout << "setup: i = " << i << ", j = " << j << ", k = " << k
+            // << std::endl;
             EXPECT_FLOAT_EQ(ts[k].adj(), 0.0);
           } else {
             std::vector<double> y0(res_d.begin(), res_d.begin() + ns);
@@ -312,4 +313,3 @@ TEST(StanAgradRevOde_integrate_ode_bdf, t0_as_param_AD) {
   test_ad();
   stan::math::recover_memory();
 }
-
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index bbcad7bed79..c88830cc5bd 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -132,10 +132,9 @@ TEST(StanMathOde_ode_bdf_tol, scalar_arg_multi_time) {
 
   var a = 1.5;
 
-  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output =
-    stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-			    nullptr, a);
-
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
 
   output[0](0).grad();
 

From 1b2b06697d9f4b1d88861aee90ae2a9a9f1604ea Mon Sep 17 00:00:00 2001
From: rok-cesnovar <rok.cesnovar@fri.uni-lj.si>
Date: Fri, 22 May 2020 19:47:52 +0200
Subject: [PATCH 118/189] template parameter fixes, reversed order of functions

---
 stan/math/prim/functor/ode_rk45.hpp | 104 ++++++++++++++--------------
 stan/math/rev/functor/ode_bdf.hpp   |  42 +++++------
 2 files changed, 73 insertions(+), 73 deletions(-)

diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index d45d42662af..0e99f80166f 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -12,58 +12,6 @@
 namespace stan {
 namespace math {
 
-/**
- * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
- * times, { t1, t2, t3, ... } using the non-stiff Runge-Kutta 45 solver in Boost
- * with a relative tolerance of 1e-10, an absolute tolerance of 1e-10, and
- * taking a maximum of 1e8 steps.
- *
- * If the system of equations is stiff, <code>ode_bdf</code> will likely be
- * faster.
- *
- * \p f must define an operator() with the signature as:
- *   template<typename T_t, typename T_y, typename... T_Args>
- *   Eigen::Matrix<stan::return_type_t<T_t, T_y, T_Args...>, Eigen::Dynamic, 1>
- *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
- *     std::ostream* msgs, const T_Args&... args);
- *
- * t is the time, y is the state, msgs is a stream for error messages, and args
- * are optional arguments passed to the ODE solve function (which are passed
- * through to \p f without modification).
- *
- * @tparam F Type of ODE right hand side
- * @tparam T_0 Type of initial time
- * @tparam T_ts Type of output times
- * @tparam T_Args Types of pass-through parameters
- *
- * @param f Right hand side of the ODE
- * @param y0 Initial state
- * @param t0 Initial time
- * @param ts Times at which to solve the ODE at. All values must be sorted and
- *   not less than t0.
- * @param relative_tolerance Relative tolerance passed to CVODES
- * @param absolute_tolerance Absolute tolerance passed to CVODES
- * @param max_num_steps Upper limit on the number of integration steps to
- *   take between each output (error if exceeded)
- * @param[in, out] msgs the print stream for warning messages
- * @param args Extra arguments passed unmodified through to ODE right hand side
- * @return Solution to ODE at times \p ts
- */
-template <typename F, typename T_initial, typename T_t0, typename T_ts,
-          typename... Args>
-std::vector<
-    Eigen::Matrix<stan::return_type_t<T_initial, Args...>, Eigen::Dynamic, 1>>
-ode_rk45(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-         double t0, const std::vector<double>& ts, std::ostream* msgs,
-         const Args&... args) {
-  double relative_tolerance = 1e-10;
-  double absolute_tolerance = 1e-10;
-  long int max_num_steps = 1e8;
-
-  return ode_rk45_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
-                      max_num_steps, msgs, args...);
-}
-
 /**
  * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
  * times, { t1, t2, t3, ... } using the non-stiff Runge-Kutta 45 solver in Boost
@@ -192,6 +140,58 @@ ode_rk45_tol(const F& f,
   return y;
 }
 
+/**
+ * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
+ * times, { t1, t2, t3, ... } using the non-stiff Runge-Kutta 45 solver in Boost
+ * with a relative tolerance of 1e-10, an absolute tolerance of 1e-10, and
+ * taking a maximum of 1e8 steps.
+ *
+ * If the system of equations is stiff, <code>ode_bdf</code> will likely be
+ * faster.
+ *
+ * \p f must define an operator() with the signature as:
+ *   template<typename T_t, typename T_y, typename... T_Args>
+ *   Eigen::Matrix<stan::return_type_t<T_t, T_y, T_Args...>, Eigen::Dynamic, 1>
+ *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
+ *     std::ostream* msgs, const T_Args&... args);
+ *
+ * t is the time, y is the state, msgs is a stream for error messages, and args
+ * are optional arguments passed to the ODE solve function (which are passed
+ * through to \p f without modification).
+ *
+ * @tparam F Type of ODE right hand side
+ * @tparam T_0 Type of initial time
+ * @tparam T_ts Type of output times
+ * @tparam T_Args Types of pass-through parameters
+ *
+ * @param f Right hand side of the ODE
+ * @param y0 Initial state
+ * @param t0 Initial time
+ * @param ts Times at which to solve the ODE at. All values must be sorted and
+ *   not less than t0.
+ * @param relative_tolerance Relative tolerance passed to CVODES
+ * @param absolute_tolerance Absolute tolerance passed to CVODES
+ * @param max_num_steps Upper limit on the number of integration steps to
+ *   take between each output (error if exceeded)
+ * @param[in, out] msgs the print stream for warning messages
+ * @param args Extra arguments passed unmodified through to ODE right hand side
+ * @return Solution to ODE at times \p ts
+ */
+template <typename F, typename T_initial, typename T_t0, typename T_ts,
+          typename... Args>
+std::vector<
+    Eigen::Matrix<stan::return_type_t<T_initial, Args...>, Eigen::Dynamic, 1>>
+ode_rk45(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+         T_t0 t0, const std::vector<T_ts>& ts, std::ostream* msgs,
+         const Args&... args) {
+  double relative_tolerance = 1e-10;
+  double absolute_tolerance = 1e-10;
+  long int max_num_steps = 1e8;
+
+  return ode_rk45_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
+                      max_num_steps, msgs, args...);
+}
+
 }  // namespace math
 }  // namespace stan
 #endif
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index e6336429d62..e7a16350f22 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -12,8 +12,7 @@ namespace math {
 /**
  * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
  * times, { t1, t2, t3, ... } using the stiff backward differentiation formula
- * (BDF) solver in CVODES with a relative tolerance of 1e-10, an absolute
- * tolerance of 1e-10, and taking a maximum of 1e8 steps.
+ * BDF solver from CVODES.
  *
  * \p f must define an operator() with the signature as:
  *   template<typename T_t, typename T_y, typename... T_Args>
@@ -47,21 +46,24 @@ template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
-ode_bdf(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-        const T_t0& t0, const std::vector<T_ts>& ts, std::ostream* msgs,
-        const T_Args&... args) {
-  double relative_tolerance = 1e-10;
-  double absolute_tolerance = 1e-10;
-  long int max_num_steps = 1e8;
+ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+            const T_t0& t0, const std::vector<T_ts>& ts,
+            double relative_tolerance, double absolute_tolerance,
+            long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
+  auto integrator
+      = new stan::math::cvodes_integrator_vari<CV_BDF, F, T_initial, T_t0, T_ts,
+                                               T_Args...>(
+          f, y0, t0, ts, relative_tolerance, absolute_tolerance, max_num_steps,
+          msgs, args...);
 
-  return ode_bdf_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
-                     max_num_steps, msgs, args...);
+  return (*integrator)();
 }
 
 /**
  * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
  * times, { t1, t2, t3, ... } using the stiff backward differentiation formula
- * BDF solver from CVODES.
+ * (BDF) solver in CVODES with a relative tolerance of 1e-10, an absolute
+ * tolerance of 1e-10, and taking a maximum of 1e8 steps.
  *
  * \p f must define an operator() with the signature as:
  *   template<typename T_t, typename T_y, typename... T_Args>
@@ -95,17 +97,15 @@ template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
-ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-            const T_t0& t0, const std::vector<T_ts>& ts,
-            double relative_tolerance, double absolute_tolerance,
-            long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
-  auto integrator
-      = new stan::math::cvodes_integrator_vari<CV_BDF, F, T_initial, T_t0, T_ts,
-                                               T_Args...>(
-          f, y0, t0, ts, relative_tolerance, absolute_tolerance, max_num_steps,
-          msgs, args...);
+ode_bdf(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+        const T_t0& t0, const std::vector<T_ts>& ts, std::ostream* msgs,
+        const T_Args&... args) {
+  double relative_tolerance = 1e-10;
+  double absolute_tolerance = 1e-10;
+  long int max_num_steps = 1e8;
 
-  return (*integrator)();
+  return ode_bdf_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
+                     max_num_steps, msgs, args...);
 }
 
 }  // namespace math

From 962ba839e10177ff9440e980ff856ea747884424 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Fri, 22 May 2020 15:06:51 -0400
Subject: [PATCH 119/189] Revert back to forward mode sensitivity for cvodes
 (to make separate branch for adjoint ODEs)

---
 stan/math/rev/functor/cvodes_integrator.hpp | 662 +++++---------------
 stan/math/rev/functor/ode_bdf.hpp           |  12 +-
 2 files changed, 153 insertions(+), 521 deletions(-)

diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index a2df7919fa6..bb54b685031 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -2,7 +2,6 @@
 #define STAN_MATH_REV_FUNCTOR_INTEGRATE_ODE_CVODES_HPP
 
 #include <stan/math/rev/meta.hpp>
-#include <stan/math/rev/core/save_varis.hpp>
 #include <stan/math/rev/functor/cvodes_utils.hpp>
 #include <stan/math/rev/functor/coupled_ode_system.hpp>
 #include <stan/math/rev/functor/ode_store_sensitivities.hpp>
@@ -17,115 +16,6 @@
 namespace stan {
 namespace math {
 
-template <typename T_Return>
-inline std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> build_varis(
-    vari* ode_vari, vari**& non_chaining_varis,
-    const std::vector<Eigen::VectorXd>& y);
-
-template <>
-inline std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> build_varis<var>(
-    vari* ode_vari, vari**& non_chaining_varis,
-    const std::vector<Eigen::VectorXd>& y) {
-  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> y_return(y.size());
-
-  if (y.size() == 0) {
-    return y_return;
-  }
-
-  int N = y[0].size();
-
-  non_chaining_varis
-      = ChainableStack::instance_->memalloc_.alloc_array<vari*>(y.size() * N);
-
-  for (size_t i = 0; i < y.size(); ++i) {
-    for (size_t j = 0; j < N; j++) {
-      non_chaining_varis[i * N + j] = new vari(y[i][j], false);
-    }
-  }
-
-  for (size_t i = 0; i < y.size(); ++i) {
-    y_return[i].resize(N);
-    for (size_t j = 0; j < N; j++)
-      y_return[i][j] = var(non_chaining_varis[i * N + j]);
-  }
-
-  return y_return;
-}
-
-/*
- * If theta and y are both doubles, just pass the values through (there's
- * no autodiff to handle here).
- */
-template <>
-inline std::vector<Eigen::VectorXd> build_varis<double>(
-    vari* ode_vari, vari**& non_chaining_varis,
-    const std::vector<Eigen::VectorXd>& y) {
-  return y;
-}
-
-template <int Lmm, typename F, typename T_y0, typename T_t0, typename T_ts,
-          typename... T_Args>
-class cvodes_integrator_vari;
-
-template <int Lmm, typename F, typename T_y0, typename T_t0, typename T_ts,
-          typename... T_Args>
-class cvodes_integrator_memory : public chainable_alloc {
-  const size_t N_;
-  const F f_;
-  const Eigen::Matrix<T_y0, Eigen::Dynamic, 1> y0_;
-  const T_t0 t0_;
-  const std::vector<T_ts> ts_;
-  std::tuple<T_Args...> args_tuple_;
-  std::tuple<decltype(value_of(T_Args()))...> value_of_args_tuple_;
-  std::vector<Eigen::VectorXd> y_;
-  void* cvodes_mem_;
-  Eigen::VectorXd state;
-  N_Vector nv_state_;
-  SUNMatrix A_;
-  SUNLinearSolver LS_;
-
-  cvodes_integrator_memory(const F& f,
-                           const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
-                           const T_t0& t0, const std::vector<T_ts>& ts,
-                           const T_Args&... args)
-      : N_(y0.size()),
-        f_(f),
-        y0_(y0),
-        t0_(t0),
-        ts_(ts),
-        args_tuple_(std::make_tuple(args...)),
-        value_of_args_tuple_(std::make_tuple(value_of(args)...)),
-        y_(ts_.size()),
-        cvodes_mem_(nullptr),
-        state(value_of(y0)) {
-    if (N_ > 0) {
-      nv_state_ = N_VMake_Serial(N_, state.data());
-      A_ = SUNDenseMatrix(N_, N_);
-      LS_ = SUNDenseLinearSolver(nv_state_, A_);
-
-      cvodes_mem_ = CVodeCreate(Lmm);
-      if (cvodes_mem_ == nullptr) {
-        throw std::runtime_error("CVodeCreate failed to allocate memory");
-      }
-    }
-  }
-
-  ~cvodes_integrator_memory() {
-    if (N_ > 0) {
-      SUNLinSolFree(LS_);
-      SUNMatDestroy(A_);
-
-      N_VDestroy_Serial(nv_state_);
-
-      if (cvodes_mem_) {
-        CVodeFree(&cvodes_mem_);
-      }
-    }
-  }
-
-  friend class cvodes_integrator_vari<Lmm, F, T_y0, T_t0, T_ts, T_Args...>;
-};
-
 /**
  * Integrator interface for CVODES' ODE solvers (Adams & BDF
  * methods).
@@ -139,62 +29,54 @@ class cvodes_integrator_memory : public chainable_alloc {
  */
 template <int Lmm, typename F, typename T_y0, typename T_t0, typename T_ts,
           typename... T_Args>
-class cvodes_integrator_vari : public vari {
+class cvodes_integrator {
   using T_Return = return_type_t<T_y0, T_t0, T_ts, T_Args...>;
+  using T_y0_t0 = return_type_t<T_y0, T_t0>;
 
+  const F& f_;
+  const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1> y0_;
+  const T_t0 t0_;
+  const std::vector<T_ts>& ts_;
+  std::tuple<const T_Args&...> args_tuple_;
+  std::tuple<decltype(value_of(T_Args()))...> value_of_args_tuple_;
   const size_t N_;
-  bool returned_;
   std::ostream* msgs_;
   double relative_tolerance_;
   double absolute_tolerance_;
   long int max_num_steps_;
 
-  const size_t t0_vars_;
-  const size_t ts_vars_;
   const size_t y0_vars_;
   const size_t args_vars_;
 
-  vari** non_chaining_varis_;
-
-  vari** t0_varis_;
-  vari** ts_varis_;
-  vari** y0_varis_;
-  vari** args_varis_;
+  coupled_ode_system<F, T_y0_t0, T_Args...> coupled_ode_;
 
-  cvodes_integrator_memory<Lmm, F, T_y0, T_t0, T_ts, T_Args...>* memory;
+  Eigen::VectorXd coupled_state_;
+  N_Vector nv_state_;
+  N_Vector* nv_state_sens_;
+  SUNMatrix A_;
+  SUNLinearSolver LS_;
 
   /**
    * Implements the function of type CVRhsFn which is the user-defined
    * ODE RHS passed to CVODES.
    */
   static int cv_rhs(realtype t, N_Vector y, N_Vector ydot, void* user_data) {
-    const cvodes_integrator_vari* integrator
-        = static_cast<const cvodes_integrator_vari*>(user_data);
+    const cvodes_integrator* integrator
+        = static_cast<const cvodes_integrator*>(user_data);
     integrator->rhs(t, NV_DATA_S(y), NV_DATA_S(ydot));
     return 0;
   }
 
   /**
-   * Implements the function of type CVRhsFnB which is the
-   * RHS of the backward ODE system.
-   */
-  static int cv_rhs_adj_sens(realtype t, N_Vector y, N_Vector yB,
-                             N_Vector yBdot, void* user_data) {
-    const cvodes_integrator_vari* integrator
-        = static_cast<const cvodes_integrator_vari*>(user_data);
-    integrator->rhs_adj_sens(t, y, yB, yBdot);
-    return 0;
-  }
-
-  /**
-   * Implements the function of type CVQuadRhsFnB which is the
-   * RHS of the backward ODE system's quadrature.
+   * Implements the function of type CVSensRhsFn which is the
+   * RHS of the sensitivity ODE system.
    */
-  static int cv_quad_rhs_adj(realtype t, N_Vector y, N_Vector yB,
-                             N_Vector qBdot, void* user_data) {
-    const cvodes_integrator_vari* integrator
-        = static_cast<const cvodes_integrator_vari*>(user_data);
-    integrator->quad_rhs_adj(t, y, yB, qBdot);
+  static int cv_rhs_sens(int Ns, realtype t, N_Vector y, N_Vector ydot,
+                         N_Vector* yS, N_Vector* ySdot, void* user_data,
+                         N_Vector tmp1, N_Vector tmp2) {
+    const cvodes_integrator* integrator
+        = static_cast<const cvodes_integrator*>(user_data);
+    integrator->rhs_sens(t, NV_DATA_S(y), yS, ySdot);
     return 0;
   }
 
@@ -207,22 +89,9 @@ class cvodes_integrator_vari : public vari {
   static int cv_jacobian_states(realtype t, N_Vector y, N_Vector fy,
                                 SUNMatrix J, void* user_data, N_Vector tmp1,
                                 N_Vector tmp2, N_Vector tmp3) {
-    const cvodes_integrator_vari* integrator
-        = static_cast<const cvodes_integrator_vari*>(user_data);
-    integrator->jacobian_states(t, y, J);
-    return 0;
-  }
-
-  /**
-   * Implements the CVLsJacFnB function for evaluating the jacobian of
-   * the adjoint problem.
-   */
-  static int cv_jacobian_adj(realtype t, N_Vector y, N_Vector yB, N_Vector fyB,
-                             SUNMatrix J, void* user_data, N_Vector tmp1,
-                             N_Vector tmp2, N_Vector tmp3) {
-    const cvodes_integrator_vari* integrator
-        = static_cast<const cvodes_integrator_vari*>(user_data);
-    integrator->jacobian_adj(t, y, J);
+    const cvodes_integrator* integrator
+        = static_cast<const cvodes_integrator*>(user_data);
+    integrator->jacobian_states(t, NV_DATA_S(y), J);
     return 0;
   }
 
@@ -233,9 +102,9 @@ class cvodes_integrator_vari : public vari {
   inline void rhs(double t, const double y[], double dy_dt[]) const {
     const Eigen::VectorXd y_vec = Eigen::Map<const Eigen::VectorXd>(y, N_);
 
-    Eigen::VectorXd dy_dt_vec = apply(
-        [&](auto&&... args) { return memory->f_(t, y_vec, msgs_, args...); },
-        memory->value_of_args_tuple_);
+    Eigen::VectorXd dy_dt_vec
+        = apply([&](auto&&... args) { return f_(t, y_vec, msgs_, args...); },
+                value_of_args_tuple_);
 
     check_size_match("cvodes_integrator::rhs", "dy_dt", dy_dt_vec.size(),
                      "states", N_);
@@ -243,105 +112,20 @@ class cvodes_integrator_vari : public vari {
     std::copy(dy_dt_vec.data(), dy_dt_vec.data() + dy_dt_vec.size(), dy_dt);
   }
 
-  /*
-   * Calculate the adjoint sensitivity RHS for varying initial conditions
-   * and parameters
-   *
-   * @param[in] initial var vector
-   * @param[in] param var vector
-   * @param[in] t time
-   * @param[in] y state of the base ODE system
-   * @param[in] yB state of the adjoint ODE system
-   * @param[out] yBdot evaluation of adjoint ODE RHS
-   */
-  void rhs_adj_sens(double t, N_Vector y, N_Vector yB, N_Vector yBdot) const {
-    Eigen::Map<Eigen::VectorXd> y_vec(NV_DATA_S(y), N_);
-    Eigen::Map<Eigen::VectorXd> lambda(NV_DATA_S(yB), N_);
-    Eigen::Map<Eigen::VectorXd> lambda_dot(NV_DATA_S(yBdot), N_);
-    lambda_dot = Eigen::VectorXd::Zero(N_);
-
-    const nested_rev_autodiff nested;
-
-    Eigen::Matrix<var, Eigen::Dynamic, 1> y_vars(y_vec.size());
-    for (size_t i = 0; i < y_vars.size(); ++i)
-      y_vars(i) = new vari(y_vec(i));
-
-    Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars = apply(
-        [&](auto&&... args) { return memory->f_(t, y_vars, msgs_, args...); },
-        memory->value_of_args_tuple_);
-
-    check_size_match("coupled_ode_system1", "dy_dt", f_y_t_vars.size(),
-                     "states", N_);
-
-    for (size_t i = 0; i < f_y_t_vars.size(); ++i) {
-      f_y_t_vars(i).vi_->adj_ = -lambda(i);
-    }
-
-    grad();
-
-    for (size_t i = 0; i < y_vars.size(); ++i) {
-      lambda_dot(i) = y_vars(i).adj();
-    }
-  }
-
-  /*
-   * Calculate the RHS for the quadrature part of the adjoint ODE problem.
-   *
-   * @param[in] initial var vector
-   * @param[in] param var vector
-   * @param[in] t time
-   * @param[in] y state of the base ODE system
-   * @param[in] yB state of the adjoint ODE system
-   * @param[out] qBdot evaluation of adjoint ODE quadrature RHS
-   */
-  void quad_rhs_adj(double t, N_Vector y, N_Vector yB, N_Vector qBdot) const {
-    Eigen::VectorXd y_vec = Eigen::Map<Eigen::VectorXd>(NV_DATA_S(y), N_);
-    Eigen::Map<Eigen::VectorXd> lambda(NV_DATA_S(yB), N_);
-    Eigen::Map<Eigen::VectorXd> mu_dot(NV_DATA_S(qBdot), args_vars_);
-    mu_dot = Eigen::VectorXd::Zero(args_vars_);
-
-    nested_rev_autodiff nested;
-
-    auto local_args_tuple = apply(
-        [&](auto&&... args) {
-          return std::tuple<decltype(deep_copy_vars(args))...>(
-              deep_copy_vars(args)...);
-        },
-        memory->args_tuple_);
-
-    Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars = apply(
-        [&](auto&&... args) { return memory->f_(t, y_vec, msgs_, args...); },
-        local_args_tuple);
-
-    check_size_match("coupled_ode_system2", "dy_dt", f_y_t_vars.size(),
-                     "states", N_);
-
-    for (size_t i = 0; i < f_y_t_vars.size(); ++i) {
-      f_y_t_vars(i).vi_->adj_ = -lambda(i);
-    }
-
-    grad();
-
-    apply([&](auto&&... args) { accumulate_adjoints(mu_dot.data(), args...); },
-          local_args_tuple);
-  }
-
   /**
    * Calculates the jacobian of the ODE RHS wrt to its states y at the
    * given time-point t and state y.
    */
-  inline void jacobian_states(double t, N_Vector y, SUNMatrix J) const {
+  inline void jacobian_states(double t, const double y[], SUNMatrix J) const {
     Eigen::VectorXd fy;
     Eigen::MatrixXd Jfy;
 
     auto f_wrapped = [&](const Eigen::Matrix<var, Eigen::Dynamic, 1>& y) {
-      return apply(
-          [&](auto&&... args) { return memory->f_(t, y, msgs_, args...); },
-          memory->value_of_args_tuple_);
+      return apply([&](auto&&... args) { return f_(t, y, msgs_, args...); },
+                   value_of_args_tuple_);
     };
 
-    jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(NV_DATA_S(y), N_), fy,
-             Jfy);
+    jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(y, N_), fy, Jfy);
 
     for (size_t j = 0; j < Jfy.cols(); ++j) {
       for (size_t i = 0; i < Jfy.rows(); ++i) {
@@ -350,31 +134,25 @@ class cvodes_integrator_vari : public vari {
     }
   }
 
-  /*
-   * Calculate the Jacobian of the RHS of the adjoint ODE (see rhs_adj_sens
-   * below for citation for how this is done)
-   *
-   * @param[in] y State of system
-   * @param[in] t Time
-   * @param[out] J CVode structure where output is to be stored
+  /**
+   * Calculates the RHS of the sensitivity ODE system which
+   * corresponds to the coupled ode system from which the first N
+   * states are omitted, since the first N states are the ODE RHS
+   * which CVODES separates from the main ODE RHS.
    */
-  inline void jacobian_adj(double t, N_Vector y, SUNMatrix J) const {
-    Eigen::VectorXd fy;
-    Eigen::MatrixXd Jfy;
-
-    auto f_wrapped = [&](const Eigen::Matrix<var, Eigen::Dynamic, 1>& y) {
-      return apply(
-          [&](auto&&... args) { return memory->f_(t, y, msgs_, args...); },
-          memory->value_of_args_tuple_);
-    };
-
-    jacobian(f_wrapped, Eigen::Map<const Eigen::VectorXd>(NV_DATA_S(y), N_), fy,
-             Jfy);
-
-    for (size_t j = 0; j < Jfy.cols(); ++j) {
-      for (size_t i = 0; i < Jfy.rows(); ++i) {
-        SM_ELEMENT_D(J, j, i) = -Jfy(i, j);
-      }
+  inline void rhs_sens(double t, const double y[], N_Vector* yS,
+                       N_Vector* ySdot) const {
+    Eigen::VectorXd z(coupled_state_.size());
+    Eigen::VectorXd dz_dt(coupled_state_.size());
+    std::copy(y, y + N_, z.data());
+    for (std::size_t s = 0; s < y0_vars_ + args_vars_; s++) {
+      std::copy(NV_DATA_S(yS[s]), NV_DATA_S(yS[s]) + N_,
+                z.data() + (s + 1) * N_);
+    }
+    coupled_ode_(z, dz_dt, t);
+    for (std::size_t s = 0; s < y0_vars_ + args_vars_; s++) {
+      std::move(dz_dt.data() + (s + 1) * N_, dz_dt.data() + (s + 2) * N_,
+                NV_DATA_S(ySdot[s]));
     }
   }
 
@@ -398,45 +176,32 @@ class cvodes_integrator_vari : public vari {
    * @return a vector of states, each state being a vector of the
    * same size as the state variable, corresponding to a time in ts.
    */
-  cvodes_integrator_vari(const F& f,
-                         const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
-                         const T_t0& t0, const std::vector<T_ts>& ts,
-                         double relative_tolerance, double absolute_tolerance,
-                         long int max_num_steps, std::ostream* msgs,
-                         const T_Args&... args)
-      : vari(NOT_A_NUMBER),
+  cvodes_integrator(const F& f,
+                    const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
+                    const T_t0& t0, const std::vector<T_ts>& ts,
+                    double relative_tolerance, double absolute_tolerance,
+                    long int max_num_steps, std::ostream* msgs,
+                    const T_Args&... args)
+      : f_(f),
+        y0_(y0.unaryExpr([](const T_y0& val) { return T_y0_t0(val); })),
+        t0_(t0),
+        ts_(ts),
+        args_tuple_(args...),
+        value_of_args_tuple_(value_of(args)...),
         N_(y0.size()),
-        returned_(false),
-        memory(NULL),
         msgs_(msgs),
         relative_tolerance_(relative_tolerance),
         absolute_tolerance_(absolute_tolerance),
         max_num_steps_(max_num_steps),
-        t0_vars_(count_vars(t0)),
-        ts_vars_(count_vars(ts)),
-        y0_vars_(count_vars(y0)),
+        y0_vars_(count_vars(y0_)),
         args_vars_(count_vars(args...)),
-        t0_varis_(
-            ChainableStack::instance_->memalloc_.alloc_array<vari*>(t0_vars_)),
-        ts_varis_(
-            ChainableStack::instance_->memalloc_.alloc_array<vari*>(ts_vars_)),
-        y0_varis_(
-            ChainableStack::instance_->memalloc_.alloc_array<vari*>(y0_vars_)),
-        args_varis_(ChainableStack::instance_->memalloc_.alloc_array<vari*>(
-            args_vars_)) {
+        coupled_ode_(f, y0_, msgs, args...),
+        coupled_state_(coupled_ode_.initial_state()) {
     const char* fun = "cvodes_integrator::integrate";
 
-    memory = new cvodes_integrator_memory<Lmm, F, T_y0, T_t0, T_ts, T_Args...>(
-        f, y0, t0, ts, args...);
-
-    save_varis(t0_varis_, t0);
-    save_varis(ts_varis_, ts);
-    save_varis(y0_varis_, y0);
-    save_varis(args_varis_, args...);
-
-    check_finite(fun, "initial state", y0);
-    check_finite(fun, "initial time", t0);
-    check_finite(fun, "times", ts);
+    check_finite(fun, "initial state", y0_);
+    check_finite(fun, "initial time", t0_);
+    check_finite(fun, "times", ts_);
 
     // Code from: https://stackoverflow.com/a/17340003 . Should probably do
     // something better
@@ -445,18 +210,38 @@ class cvodes_integrator_vari : public vari {
           std::vector<int> unused_temp{
               0, (check_finite(fun, "ode parameters and data", args), 0)...};
         },
-        memory->args_tuple_);
+        args_tuple_);
 
-    check_nonzero_size(fun, "times", ts);
-    check_nonzero_size(fun, "initial state", y0);
-    check_ordered(fun, "times", ts);
-    check_less(fun, "initial time", t0, ts[0]);
+    check_nonzero_size(fun, "times", ts_);
+    check_nonzero_size(fun, "initial state", y0_);
+    check_ordered(fun, "times", ts_);
+    check_less(fun, "initial time", t0_, ts_[0]);
     check_positive_finite(fun, "relative_tolerance", relative_tolerance_);
     check_positive_finite(fun, "absolute_tolerance", absolute_tolerance_);
     check_positive(fun, "max_num_steps", max_num_steps_);
+
+    nv_state_ = N_VMake_Serial(N_, &coupled_state_[0]);
+    nv_state_sens_ = nullptr;
+    A_ = SUNDenseMatrix(N_, N_);
+    LS_ = SUNDenseLinearSolver(nv_state_, A_);
+
+    if (y0_vars_ + args_vars_ > 0) {
+      nv_state_sens_
+          = N_VCloneVectorArrayEmpty_Serial(y0_vars_ + args_vars_, nv_state_);
+      for (std::size_t i = 0; i < y0_vars_ + args_vars_; i++) {
+        NV_DATA_S(nv_state_sens_[i]) = &coupled_state_[N_] + i * N_;
+      }
+    }
   }
 
-  ~cvodes_integrator_vari() {}
+  ~cvodes_integrator() {
+    SUNLinSolFree(LS_);
+    SUNMatDestroy(A_);
+    N_VDestroy_Serial(nv_state_);
+    if (y0_vars_ + args_vars_ > 0) {
+      N_VDestroyVectorArray_Serial(nv_state_sens_, y0_vars_ + args_vars_);
+    }
+  }
 
   /**
    * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
@@ -466,238 +251,85 @@ class cvodes_integrator_vari : public vari {
    * @return std::vector of Eigen::Matrix of the states of the ODE, one for each
    *   solution time (excluding the initial state)
    */
-  std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> operator()() {
-    const double t0_dbl = value_of(memory->t0_);
-    const std::vector<double> ts_dbl = value_of(memory->ts_);
-
-    check_flag_sundials(
-        CVodeInit(memory->cvodes_mem_, &cvodes_integrator_vari::cv_rhs, t0_dbl,
-                  memory->nv_state_),
-        "CVodeInit");
-
-    // Assign pointer to this as user data
-    check_flag_sundials(
-        CVodeSetUserData(memory->cvodes_mem_, reinterpret_cast<void*>(this)),
-        "CVodeSetUserData");
-
-    cvodes_set_options(memory->cvodes_mem_, relative_tolerance_,
-                       absolute_tolerance_, max_num_steps_);
-
-    // for the stiff solvers we need to reserve additional memory
-    // and provide a Jacobian function call. new API since 3.0.0:
-    // create matrix object and linear solver object; resource
-    // (de-)allocation is handled in the cvodes_ode_data
-    check_flag_sundials(
-        CVodeSetLinearSolver(memory->cvodes_mem_, memory->LS_, memory->A_),
-        "CVodeSetLinearSolver");
-
-    check_flag_sundials(
-        CVodeSetJacFn(memory->cvodes_mem_,
-                      &cvodes_integrator_vari::cv_jacobian_states),
-        "CVodeSetJacFn");
-
-    // initialize forward sensitivity system of CVODES as needed
-    if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ > 0) {
-      check_flag_sundials(CVodeAdjInit(memory->cvodes_mem_, 25, CV_HERMITE),
-                          "CVodeAdjInit");
-    }
+  std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>>
+  operator()() {  // NOLINT(runtime/int)
+    std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> y;
 
-    double t_init = t0_dbl;
-    for (size_t n = 0; n < ts_dbl.size(); ++n) {
-      double t_final = ts_dbl[n];
+    const double t0_dbl = value_of(t0_);
+    const std::vector<double> ts_dbl = value_of(ts_);
 
-      if (t_final != t_init) {
-        if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ > 0) {
-          int ncheck;
-          check_flag_sundials(
-              CVodeF(memory->cvodes_mem_, t_final, memory->nv_state_, &t_init,
-                     CV_NORMAL, &ncheck),
-              "CVodeF");
-        } else {
-          check_flag_sundials(CVode(memory->cvodes_mem_, t_final,
-                                    memory->nv_state_, &t_init, CV_NORMAL),
-                              "CVode");
-        }
-      }
-
-      memory->y_[n] = memory->state;
-
-      t_init = t_final;
-    }
-
-    returned_ = true;
-    return build_varis<T_Return>(this, non_chaining_varis_, memory->y_);
-  }
-
-  virtual void chain() {
-    // std::cout << "chain" << std::endl; <-- Good way to verify it's only
-    //  being called once
-    if (memory == NULL)
-      return;
-
-    if (memory->cvodes_mem_ == NULL)
-      return;
-
-    if (returned_ == false)
-      return;
-
-    if (t0_vars_ + ts_vars_ + y0_vars_ + args_vars_ == 0) {
-      return;
+    void* cvodes_mem = CVodeCreate(Lmm);
+    if (cvodes_mem == nullptr) {
+      throw std::runtime_error("CVodeCreate failed to allocate memory");
     }
 
-    Eigen::VectorXd state_sens(N_);
-    Eigen::VectorXd quad(args_vars_);
-    N_Vector nv_state_sens
-        = N_VMake_Serial(state_sens.size(), state_sens.data());
-    N_Vector nv_quad = N_VMake_Serial(quad.size(), quad.data());
-    N_VConst(0.0, nv_state_sens);
-    N_VConst(0.0, nv_quad);
-
-    SUNMatrix AB_ = SUNDenseMatrix(N_, N_);
-    SUNLinearSolver LSB_ = SUNDenseLinearSolver(nv_state_sens, AB_);
-
     try {
-      int indexB;
-
-      // This is all boilerplate CVODES setting up the adjoint ODE to solve
-      check_flag_sundials(CVodeCreateB(memory->cvodes_mem_, Lmm, &indexB),
-                          "CVodeCreateB");
-
-      check_flag_sundials(CVodeSetUserDataB(memory->cvodes_mem_, indexB,
-                                            reinterpret_cast<void*>(this)),
-                          "CVodeSetUserDataB");
-
-      // The ode_rhs_adj_sense functions passed in here cause problems with
-      // the autodiff stack (they can cause reallocations of the internal
-      // vectors and cause segfaults)
-      check_flag_sundials(
-          CVodeInitB(memory->cvodes_mem_, indexB,
-                     &cvodes_integrator_vari::cv_rhs_adj_sens,
-                     value_of(memory->ts_.back()), nv_state_sens),
-          "CVodeInitB");
-
       check_flag_sundials(
-          CVodeSStolerancesB(memory->cvodes_mem_, indexB, relative_tolerance_,
-                             absolute_tolerance_),
-          "CVodeSStolerancesB");
+          CVodeInit(cvodes_mem, &cvodes_integrator::cv_rhs, t0_dbl, nv_state_),
+          "CVodeInit");
 
+      // Assign pointer to this as user data
       check_flag_sundials(
-          CVodeSetLinearSolverB(memory->cvodes_mem_, indexB, LSB_, AB_),
-          "CVodeSetLinearSolverB");
-
-      // The same autodiff issue that applies to ode_rhs_adj_sense applies
-      // here
+          CVodeSetUserData(cvodes_mem, reinterpret_cast<void*>(this)),
+          "CVodeSetUserData");
+
+      cvodes_set_options(cvodes_mem, relative_tolerance_, absolute_tolerance_,
+                         max_num_steps_);
+
+      // for the stiff solvers we need to reserve additional memory
+      // and provide a Jacobian function call. new API since 3.0.0:
+      // create matrix object and linear solver object; resource
+      // (de-)allocation is handled in the cvodes_ode_data
+      check_flag_sundials(CVodeSetLinearSolver(cvodes_mem, LS_, A_),
+                          "CVodeSetLinearSolver");
       check_flag_sundials(
-          CVodeSetJacFnB(memory->cvodes_mem_, indexB,
-                         &cvodes_integrator_vari::cv_jacobian_adj),
-          "CVodeSetJacFnB");
+          CVodeSetJacFn(cvodes_mem, &cvodes_integrator::cv_jacobian_states),
+          "CVodeSetJacFn");
 
-      // Allocate space for backwards quadrature
-      if (args_vars_ > 0) {
+      // initialize forward sensitivity system of CVODES as needed
+      if (y0_vars_ + args_vars_ > 0) {
         check_flag_sundials(
-            CVodeQuadInitB(memory->cvodes_mem_, indexB,
-                           &cvodes_integrator_vari::cv_quad_rhs_adj, nv_quad),
-            "CVodeQuadInitB");
+            CVodeSensInit(cvodes_mem, static_cast<int>(y0_vars_ + args_vars_),
+                          CV_STAGGERED, &cvodes_integrator::cv_rhs_sens,
+                          nv_state_sens_),
+            "CVodeSensInit");
 
-        check_flag_sundials(
-            CVodeQuadSStolerancesB(memory->cvodes_mem_, indexB,
-                                   relative_tolerance_, absolute_tolerance_),
-            "CVodeQuadSStolerancesB");
-
-        check_flag_sundials(
-            CVodeSetQuadErrConB(memory->cvodes_mem_, indexB, SUNTRUE),
-            "CVodeSetQuadErrConB");
+        check_flag_sundials(CVodeSensEEtolerances(cvodes_mem),
+                            "CVodeSensEEtolerances");
       }
 
-      // At every time step, collect the adjoints from the output
-      // variables and re-initialize the solver
-      double t_init = value_of(memory->ts_.back());
-      for (int i = memory->ts_.size() - 1; i >= 0; --i) {
-        // Take in the adjoints from all the output variables at this point
-        // in time
-        Eigen::VectorXd step_sens = Eigen::VectorXd::Zero(N_);
-        for (int j = 0; j < N_; j++) {
-          // std::cout << "i: " << i << ", j: " << j << std::endl;
-          state_sens(j) += non_chaining_varis_[i * N_ + j]->adj_;
-          step_sens(j) += non_chaining_varis_[i * N_ + j]->adj_;
-        }
+      double t_init = t0_dbl;
+      for (size_t n = 0; n < ts_.size(); ++n) {
+        double t_final = ts_dbl[n];
 
-        if (ts_vars_ > 0 && i >= 0) {
-          ts_varis_[i]->adj_ += apply(
-              [&](auto&&... args) {
-                double adj = step_sens.dot(
-                    memory->f_(t_init, memory->y_[i], msgs_, args...));
-                // std::cout << "adj: " << adj << ", i: " << i << std::endl;
-                return adj;
-              },
-              memory->value_of_args_tuple_);
-        }
-
-        double t_final = value_of((i > 0) ? memory->ts_[i - 1] : memory->t0_);
         if (t_final != t_init) {
           check_flag_sundials(
-              CVodeReInitB(memory->cvodes_mem_, indexB, t_init, nv_state_sens),
-              "CVodeReInitB");
-
-          if (args_vars_ > 0) {
-            check_flag_sundials(
-                CVodeQuadReInitB(memory->cvodes_mem_, indexB, nv_quad),
-                "CVodeQuadReInitB");
-          }
-
-          check_flag_sundials(CVodeB(memory->cvodes_mem_, t_final, CV_NORMAL),
-                              "CVodeB");
+              CVode(cvodes_mem, t_final, nv_state_, &t_init, CV_NORMAL),
+              "CVode");
+        }
 
-          check_flag_sundials(
-              CVodeGetB(memory->cvodes_mem_, indexB, &t_init, nv_state_sens),
-              "CVodeGetB");
-
-          if (args_vars_ > 0) {
-            check_flag_sundials(
-                CVodeGetQuadB(memory->cvodes_mem_, indexB, &t_init, nv_quad),
-                "CVodeGetQuadB");
-          }
+        if (y0_vars_ + args_vars_ > 0) {
+          check_flag_sundials(CVodeGetSens(cvodes_mem, &t_init, nv_state_sens_),
+                              "CVodeGetSens");
         }
-      }
 
-      if (t0_vars_ > 0) {
-        Eigen::VectorXd y0d = value_of(memory->y0_);
-        t0_varis_[0]->adj_ += apply(
+        y.emplace_back(apply(
             [&](auto&&... args) {
-              return -state_sens.dot(memory->f_(t_init, y0d, msgs_, args...));
+              return ode_store_sensitivities(f_, coupled_state_, y0_, t0_,
+                                             ts_[n], msgs_, args...);
             },
-            memory->value_of_args_tuple_);
-      }
+            args_tuple_));
 
-      if (args_vars_ > 0) {
-        check_flag_sundials(
-            CVodeGetQuadB(memory->cvodes_mem_, indexB, &t_init, nv_quad),
-            "CVodeGetQuadB");
-      }
-
-      // After integrating all the way back to t0, we finally have the
-      // the adjoints we wanted
-      // These are the dlog_density / d(initial_conditions[s]) adjoints
-      for (size_t s = 0; s < y0_vars_; s++) {
-        y0_varis_[s]->adj_ += state_sens(s);
-      }
-
-      // These are the dlog_density / d(parameters[s]) adjoints
-      for (size_t s = 0; s < args_vars_; s++) {
-        args_varis_[s]->adj_ += quad(s);
+        t_init = t_final;
       }
     } catch (const std::exception& e) {
-      SUNLinSolFree(LSB_);
-      SUNMatDestroy(AB_);
-      N_VDestroy_Serial(nv_state_sens);
-      N_VDestroy_Serial(nv_quad);
+      CVodeFree(&cvodes_mem);
       throw;
     }
 
-    SUNLinSolFree(LSB_);
-    SUNMatDestroy(AB_);
-    N_VDestroy_Serial(nv_state_sens);
-    N_VDestroy_Serial(nv_quad);
+    CVodeFree(&cvodes_mem);
+
+    return y;
   }
 };  // cvodes integrator
 
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index e6336429d62..0c08236cc92 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -99,13 +99,13 @@ ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
             const T_t0& t0, const std::vector<T_ts>& ts,
             double relative_tolerance, double absolute_tolerance,
             long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
-  auto integrator
-      = new stan::math::cvodes_integrator_vari<CV_BDF, F, T_initial, T_t0, T_ts,
-                                               T_Args...>(
-          f, y0, t0, ts, relative_tolerance, absolute_tolerance, max_num_steps,
-          msgs, args...);
+  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts,
+		    T_Args...> integrator(f, y0, t0, ts,
+					  relative_tolerance, absolute_tolerance,
+					  max_num_steps,
+					  msgs, args...);
 
-  return (*integrator)();
+  return integrator();
 }
 
 }  // namespace math

From 46d7230b424d88275251a2c02ac08a07ec871aa0 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 22 May 2020 19:19:08 +0000
Subject: [PATCH 120/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

---
 stan/math/rev/functor/ode_bdf.hpp | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index e8ac6e58077..f0021dcb358 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -50,11 +50,9 @@ ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
             const T_t0& t0, const std::vector<T_ts>& ts,
             double relative_tolerance, double absolute_tolerance,
             long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
-  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts,
-		    T_Args...> integrator(f, y0, t0, ts,
-					  relative_tolerance, absolute_tolerance,
-					  max_num_steps,
-					  msgs, args...);
+  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
+      f, y0, t0, ts, relative_tolerance, absolute_tolerance, max_num_steps,
+      msgs, args...);
 
   return integrator();
 }

From 7f5e7dba84a8e52ef2b45652ee841e428f0e669c Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 25 May 2020 11:40:36 -0400
Subject: [PATCH 121/189] Made some minor changes with coupled_ode_system to
 make new code match speed of old code (design-doc #19)

---
 stan/math/rev/functor/coupled_ode_system.hpp | 27 ++++++++++----------
 stan/math/rev/functor/cvodes_integrator.hpp  |  2 +-
 2 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index 32679eb9e0f..ac82ac4f413 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -130,35 +130,36 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
         },
         args_tuple_);
 
-    Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars
-        = apply([&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
+    Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars = apply([&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
                 local_args_tuple);
 
     check_size_match("coupled_ode_system", "dy_dt", f_y_t_vars.size(), "states",
                      N_);
 
+    Eigen::VectorXd args_adjoints(args_vars_);
     for (size_t i = 0; i < N_; i++) {
       dz_dt(i) = f_y_t_vars(i).val();
       f_y_t_vars(i).grad();
-      for (size_t j = 0; j < y0_vars_; j++) {
-        // orders derivatives by equation (i.e. if there are 2 eqns
-        // (y1, y2) and 2 parameters (a, b), dy_dt will be ordered as:
-        // dy1_dt, dy2_dt, dy1_da, dy2_da, dy1_db, dy2_db
-        double temp_deriv = 0;
-        const size_t offset = N_ + N_ * j;
-        for (size_t k = 0; k < N_; k++) {
-          temp_deriv += z[N_ + N_ * j + k] * y_vars[k].adj();
-        }
 
-        dz_dt[N_ + N_ * j + i] = temp_deriv;
+      for (size_t j = 0; j < y0_vars_; j++) {
+	// orders derivatives by equation (i.e. if there are 2 eqns
+	// (y1, y2) and 2 parameters (a, b), dy_dt will be ordered as:
+	// dy1_dt, dy2_dt, dy1_da, dy2_da, dy1_db, dy2_db
+	double temp_deriv = 0;
+	for (size_t k = 0; k < N_; k++) {
+	  temp_deriv += z[N_ + N_ * j + k] * y_vars[k].adj();
+	}
+
+	dz_dt[N_ + N_ * j + i] = temp_deriv;
       }
 
-      Eigen::VectorXd args_adjoints = Eigen::VectorXd::Zero(args_vars_);
+      args_adjoints.setZero();
       apply(
           [&](auto&&... args) {
             accumulate_adjoints(args_adjoints.data(), args...);
           },
           local_args_tuple);
+
       for (size_t j = 0; j < args_vars_; j++) {
         double temp_deriv = args_adjoints(j);
         for (size_t k = 0; k < N_; k++) {
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index bb54b685031..74f014dab0b 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -143,7 +143,7 @@ class cvodes_integrator {
   inline void rhs_sens(double t, const double y[], N_Vector* yS,
                        N_Vector* ySdot) const {
     Eigen::VectorXd z(coupled_state_.size());
-    Eigen::VectorXd dz_dt(coupled_state_.size());
+    Eigen::VectorXd dz_dt;
     std::copy(y, y + N_, z.data());
     for (std::size_t s = 0; s < y0_vars_ + args_vars_; s++) {
       std::copy(NV_DATA_S(yS[s]), NV_DATA_S(yS[s]) + N_,

From 7007256d71edfa0ed4320da69e7299152cae1969 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 25 May 2020 11:43:45 -0400
Subject: [PATCH 122/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 stan/math/rev/functor/coupled_ode_system.hpp | 21 ++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index ac82ac4f413..61205cee3eb 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -130,7 +130,8 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
         },
         args_tuple_);
 
-    Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars = apply([&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
+    Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars
+        = apply([&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
                 local_args_tuple);
 
     check_size_match("coupled_ode_system", "dy_dt", f_y_t_vars.size(), "states",
@@ -142,15 +143,15 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
       f_y_t_vars(i).grad();
 
       for (size_t j = 0; j < y0_vars_; j++) {
-	// orders derivatives by equation (i.e. if there are 2 eqns
-	// (y1, y2) and 2 parameters (a, b), dy_dt will be ordered as:
-	// dy1_dt, dy2_dt, dy1_da, dy2_da, dy1_db, dy2_db
-	double temp_deriv = 0;
-	for (size_t k = 0; k < N_; k++) {
-	  temp_deriv += z[N_ + N_ * j + k] * y_vars[k].adj();
-	}
-
-	dz_dt[N_ + N_ * j + i] = temp_deriv;
+        // orders derivatives by equation (i.e. if there are 2 eqns
+        // (y1, y2) and 2 parameters (a, b), dy_dt will be ordered as:
+        // dy1_dt, dy2_dt, dy1_da, dy2_da, dy1_db, dy2_db
+        double temp_deriv = 0;
+        for (size_t k = 0; k < N_; k++) {
+          temp_deriv += z[N_ + N_ * j + k] * y_vars[k].adj();
+        }
+
+        dz_dt[N_ + N_ * j + i] = temp_deriv;
       }
 
       args_adjoints.setZero();

From ad58f9db423d725b22305c09c8a3aefee999a538 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 25 May 2020 13:08:13 -0400
Subject: [PATCH 123/189] Allow integer initial times and output times
 (design-doc #19)

---
 stan/math/prim/functor/ode_rk45.hpp           | 12 +++----
 .../prim/functor/ode_store_sensitivities.hpp  |  8 ++---
 stan/math/rev/functor/cvodes_integrator.hpp   |  9 ++---
 .../rev/functor/ode_store_sensitivities.hpp   |  2 +-
 .../math/rev/functor/ode_bdf_rev_test.cpp     | 34 +++++++++++++++++++
 .../math/rev/functor/ode_rk45_rev_test.cpp    | 34 +++++++++++++++++++
 6 files changed, 82 insertions(+), 17 deletions(-)

diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index 0e99f80166f..42c950f0ca6 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -68,11 +68,10 @@ ode_rk45_tol(const F& f,
 
   Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1> y0 = y0_arg.unaryExpr(
       [](const T_initial& val) { return T_initial_or_t0(val); });
-  const std::vector<double> ts_dbl = value_of(ts);
 
   check_finite("integrate_ode_rk45", "initial state", y0);
   check_finite("integrate_ode_rk45", "initial time", t0);
-  check_finite("integrate_ode_rk45", "times", ts_dbl);
+  check_finite("integrate_ode_rk45", "times", ts);
 
   // Code from https://stackoverflow.com/a/17340003
   std::vector<int> unused_temp{
@@ -80,9 +79,9 @@ ode_rk45_tol(const F& f,
           0)...};
 
   check_nonzero_size("integrate_ode_rk45", "initial state", y0);
-  check_nonzero_size("integrate_ode_rk45", "times", ts_dbl);
-  check_ordered("integrate_ode_rk45", "times", ts_dbl);
-  check_less("integrate_ode_rk45", "initial time", t0, ts_dbl[0]);
+  check_nonzero_size("integrate_ode_rk45", "times", ts);
+  check_ordered("integrate_ode_rk45", "times", ts);
+  check_less("integrate_ode_rk45", "initial time", t0, ts[0]);
 
   if (relative_tolerance <= 0) {
     invalid_argument("integrate_ode_rk45", "relative_tolerance,",
@@ -105,7 +104,8 @@ ode_rk45_tol(const F& f,
   // first time in the vector must be time of initial state
   std::vector<double> ts_vec(ts.size() + 1);
   ts_vec[0] = value_of(t0);
-  std::copy(ts_dbl.begin(), ts_dbl.end(), ts_vec.begin() + 1);
+  for (size_t i = 0; i < ts.size(); ++i)
+    ts_vec[i + 1] = value_of(ts[i]);
 
   std::vector<Eigen::Matrix<return_t, Eigen::Dynamic, 1>> y;
   bool observer_initial_recorded = false;
diff --git a/stan/math/prim/functor/ode_store_sensitivities.hpp b/stan/math/prim/functor/ode_store_sensitivities.hpp
index acf0fd61992..4c30a314d10 100644
--- a/stan/math/prim/functor/ode_store_sensitivities.hpp
+++ b/stan/math/prim/functor/ode_store_sensitivities.hpp
@@ -23,12 +23,12 @@ namespace math {
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return ODE state
  */
-template <typename F, typename... Args,
-          typename = require_all_arithmetic_t<scalar_type_t<Args>...>>
+template <typename F, typename T_y0_t0, typename T_t0, typename T_t, typename... Args,
+          typename = require_all_arithmetic_t<T_y0_t0, T_t0, T_t, scalar_type_t<Args>...>>
 Eigen::VectorXd ode_store_sensitivities(const F& f,
                                         const Eigen::VectorXd& coupled_state,
-                                        const Eigen::VectorXd& y0, double t0,
-                                        double t, std::ostream* msgs,
+                                        const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0, T_t0 t0,
+                                        T_t t, std::ostream* msgs,
                                         const Args&... args) {
   return coupled_state.head(y0.size());
 }
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 74f014dab0b..91e92a88602 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -255,9 +255,6 @@ class cvodes_integrator {
   operator()() {  // NOLINT(runtime/int)
     std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> y;
 
-    const double t0_dbl = value_of(t0_);
-    const std::vector<double> ts_dbl = value_of(ts_);
-
     void* cvodes_mem = CVodeCreate(Lmm);
     if (cvodes_mem == nullptr) {
       throw std::runtime_error("CVodeCreate failed to allocate memory");
@@ -265,7 +262,7 @@ class cvodes_integrator {
 
     try {
       check_flag_sundials(
-          CVodeInit(cvodes_mem, &cvodes_integrator::cv_rhs, t0_dbl, nv_state_),
+			  CVodeInit(cvodes_mem, &cvodes_integrator::cv_rhs, value_of(t0_), nv_state_),
           "CVodeInit");
 
       // Assign pointer to this as user data
@@ -298,9 +295,9 @@ class cvodes_integrator {
                             "CVodeSensEEtolerances");
       }
 
-      double t_init = t0_dbl;
+      double t_init = value_of(t0_);
       for (size_t n = 0; n < ts_.size(); ++n) {
-        double t_final = ts_dbl[n];
+        double t_final = value_of(ts_[n]);
 
         if (t_final != t_init) {
           check_flag_sundials(
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index f2c505ccf08..4bb1dac318e 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -31,7 +31,7 @@ namespace math {
  * @return ODE state with scalar type var
  */
 template <typename F, typename T_y0_t0, typename T_t0, typename T_t,
-          typename... Args>
+          typename... Args, typename = require_any_autodiff_t<T_y0_t0, T_t0, T_t, scalar_type_t<Args>...>>
 Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
     const F& f, const Eigen::VectorXd& coupled_state,
     const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0, const T_t0& t0,
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index c88830cc5bd..b1999b81840 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -53,6 +53,40 @@ struct Cos2Arg {
   }
 };
 
+TEST(StanMathOde_ode_bdf_tol, int_t0) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  int t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
+      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+				nullptr, a);
+
+  EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
+  EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
+}
+
+TEST(StanMathOde_ode_bdf_tol, int_ts) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<int> ts = {1, 2};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
+      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+				nullptr, a);
+
+  EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
+  EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
+}
+
 TEST(StanMathOde_ode_bdf_tol, t0) {
   using stan::math::var;
 
diff --git a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
index daefbcbb19a..20f27c745f5 100644
--- a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
@@ -56,6 +56,40 @@ struct Cos2Arg {
   }
 };
 
+TEST(StanMathOde_ode_rk45_tol, int_t0) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  int t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
+      = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+				nullptr, a);
+
+  EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
+  EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
+}
+
+TEST(StanMathOde_ode_rk45_tol, int_ts) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<int> ts = {1, 2};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
+      = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+				nullptr, a);
+
+  EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
+  EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
+}
+
 TEST(StanMathOde_ode_rk45_tol, t0) {
   using stan::math::var;
 

From 8bd267f39f2ab7558b8677280c6514a0274f9bf4 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 25 May 2020 17:09:30 +0000
Subject: [PATCH 124/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

---
 .../math/prim/functor/ode_store_sensitivities.hpp | 15 ++++++++-------
 stan/math/rev/functor/cvodes_integrator.hpp       |  6 +++---
 stan/math/rev/functor/ode_store_sensitivities.hpp |  4 +++-
 test/unit/math/rev/functor/ode_bdf_rev_test.cpp   |  4 ++--
 test/unit/math/rev/functor/ode_rk45_rev_test.cpp  |  4 ++--
 5 files changed, 18 insertions(+), 15 deletions(-)

diff --git a/stan/math/prim/functor/ode_store_sensitivities.hpp b/stan/math/prim/functor/ode_store_sensitivities.hpp
index 4c30a314d10..8d394a41eb5 100644
--- a/stan/math/prim/functor/ode_store_sensitivities.hpp
+++ b/stan/math/prim/functor/ode_store_sensitivities.hpp
@@ -23,13 +23,14 @@ namespace math {
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return ODE state
  */
-template <typename F, typename T_y0_t0, typename T_t0, typename T_t, typename... Args,
-          typename = require_all_arithmetic_t<T_y0_t0, T_t0, T_t, scalar_type_t<Args>...>>
-Eigen::VectorXd ode_store_sensitivities(const F& f,
-                                        const Eigen::VectorXd& coupled_state,
-                                        const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0, T_t0 t0,
-                                        T_t t, std::ostream* msgs,
-                                        const Args&... args) {
+template <
+    typename F, typename T_y0_t0, typename T_t0, typename T_t, typename... Args,
+    typename
+    = require_all_arithmetic_t<T_y0_t0, T_t0, T_t, scalar_type_t<Args>...>>
+Eigen::VectorXd ode_store_sensitivities(
+    const F& f, const Eigen::VectorXd& coupled_state,
+    const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0, T_t0 t0, T_t t,
+    std::ostream* msgs, const Args&... args) {
   return coupled_state.head(y0.size());
 }
 
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 91e92a88602..b14aa785e62 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -261,9 +261,9 @@ class cvodes_integrator {
     }
 
     try {
-      check_flag_sundials(
-			  CVodeInit(cvodes_mem, &cvodes_integrator::cv_rhs, value_of(t0_), nv_state_),
-          "CVodeInit");
+      check_flag_sundials(CVodeInit(cvodes_mem, &cvodes_integrator::cv_rhs,
+                                    value_of(t0_), nv_state_),
+                          "CVodeInit");
 
       // Assign pointer to this as user data
       check_flag_sundials(
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 4bb1dac318e..725f5731a9e 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -31,7 +31,9 @@ namespace math {
  * @return ODE state with scalar type var
  */
 template <typename F, typename T_y0_t0, typename T_t0, typename T_t,
-          typename... Args, typename = require_any_autodiff_t<T_y0_t0, T_t0, T_t, scalar_type_t<Args>...>>
+          typename... Args,
+          typename
+          = require_any_autodiff_t<T_y0_t0, T_t0, T_t, scalar_type_t<Args>...>>
 Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
     const F& f, const Eigen::VectorXd& coupled_state,
     const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0, const T_t0& t0,
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index b1999b81840..5e6e477f455 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -64,7 +64,7 @@ TEST(StanMathOde_ode_bdf_tol, int_t0) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-				nullptr, a);
+                                nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
   EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
@@ -81,7 +81,7 @@ TEST(StanMathOde_ode_bdf_tol, int_ts) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-				nullptr, a);
+                                nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
   EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
diff --git a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
index 20f27c745f5..384a95a20dc 100644
--- a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
@@ -67,7 +67,7 @@ TEST(StanMathOde_ode_rk45_tol, int_t0) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-				nullptr, a);
+                                 nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
   EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
@@ -84,7 +84,7 @@ TEST(StanMathOde_ode_rk45_tol, int_ts) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-				nullptr, a);
+                                 nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
   EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);

From 8f28f3e5459cb1dd5bd3f8c569e4366fd2898c42 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 25 May 2020 13:24:42 -0400
Subject: [PATCH 125/189] Add new adams interface (design-doc #19)

---
 stan/math/rev/functor.hpp                     |   1 +
 stan/math/rev/functor/cvodes_integrator.hpp   |   2 +-
 stan/math/rev/functor/integrate_ode_adams.hpp |  26 +++--
 stan/math/rev/functor/ode_adams.hpp           | 110 ++++++++++++++++++
 .../functor/integrate_ode_adams_prim_test.cpp |   2 +-
 .../functor/integrate_ode_adams_rev_test.cpp  |  50 ++++----
 .../functor/integrate_ode_bdf_rev_test.cpp    |   4 +-
 7 files changed, 158 insertions(+), 37 deletions(-)
 create mode 100644 stan/math/rev/functor/ode_adams.hpp

diff --git a/stan/math/rev/functor.hpp b/stan/math/rev/functor.hpp
index 171036c0bd2..d3bf2ec7410 100644
--- a/stan/math/rev/functor.hpp
+++ b/stan/math/rev/functor.hpp
@@ -14,6 +14,7 @@
 #include <stan/math/rev/functor/integrate_dae.hpp>
 #include <stan/math/rev/functor/integrate_ode_adams.hpp>
 #include <stan/math/rev/functor/integrate_ode_bdf.hpp>
+#include <stan/math/rev/functor/ode_adams.hpp>
 #include <stan/math/rev/functor/ode_bdf.hpp>
 #include <stan/math/rev/functor/ode_store_sensitivities.hpp>
 #include <stan/math/rev/functor/jacobian.hpp>
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 91e92a88602..aad964f92ee 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -106,7 +106,7 @@ class cvodes_integrator {
         = apply([&](auto&&... args) { return f_(t, y_vec, msgs_, args...); },
                 value_of_args_tuple_);
 
-    check_size_match("cvodes_integrator::rhs", "dy_dt", dy_dt_vec.size(),
+    check_size_match("cvodes_integrator", "dy_dt", dy_dt_vec.size(),
                      "states", N_);
 
     std::copy(dy_dt_vec.data(), dy_dt_vec.data() + dy_dt_vec.size(), dy_dt);
diff --git a/stan/math/rev/functor/integrate_ode_adams.hpp b/stan/math/rev/functor/integrate_ode_adams.hpp
index fc83e15521e..1c10b3df68b 100644
--- a/stan/math/rev/functor/integrate_ode_adams.hpp
+++ b/stan/math/rev/functor/integrate_ode_adams.hpp
@@ -2,14 +2,17 @@
 #define STAN_MATH_REV_FUNCTOR_INTEGRATE_ODE_ADAMS_HPP
 
 #include <stan/math/rev/meta.hpp>
-#include <stan/math/rev/functor/cvodes_integrator.hpp>
+#include <stan/math/rev/functor/ode_adams.hpp>
 #include <ostream>
 #include <vector>
 
 namespace stan {
 namespace math {
 
-/*template <typename F, typename T_initial, typename T_param, typename T_t0,
+/**
+  *  @deprecated use <code>ode_adams</code>
+  */
+template <typename F, typename T_initial, typename T_param, typename T_t0,
         typename T_ts>
 std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>>
 integrate_ode_adams(const F& f, const std::vector<T_initial>& y0,
@@ -20,13 +23,18 @@ integrate_ode_adams(const F& f, const std::vector<T_initial>& y0,
                   double relative_tolerance = 1e-10,
                   double absolute_tolerance = 1e-10,
                   long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
-stan::math::cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts,
-                              std::vector<T_param>, std::vector<double>,
-                              std::vector<int>>
-    integrator(f, y0, t0, ts, theta, x, x_int, msgs, relative_tolerance,
-               absolute_tolerance, max_num_steps);
-return integrator.integrate();
-}*/
+  internal::integrate_ode_std_vector_interface_adapter<F> f_adapted(f);
+  auto y
+      = ode_adams_tol(f_adapted, to_vector(y0), t0, ts, relative_tolerance,
+                    absolute_tolerance, max_num_steps, msgs, theta, x, x_int);
+
+  std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>>
+      y_converted;
+  for (size_t i = 0; i < y.size(); ++i)
+    y_converted.push_back(to_array_1d(y[i]));
+
+  return y_converted;
+}
 
 }  // namespace math
 }  // namespace stan
diff --git a/stan/math/rev/functor/ode_adams.hpp b/stan/math/rev/functor/ode_adams.hpp
new file mode 100644
index 00000000000..71465593cbe
--- /dev/null
+++ b/stan/math/rev/functor/ode_adams.hpp
@@ -0,0 +1,110 @@
+#ifndef STAN_MATH_REV_FUNCTOR_ODE_ADAMS_HPP
+#define STAN_MATH_REV_FUNCTOR_ODE_ADAMS_HPP
+
+#include <stan/math/rev/meta.hpp>
+#include <stan/math/rev/functor/cvodes_integrator.hpp>
+#include <ostream>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+/**
+ * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
+ * times, { t1, t2, t3, ... } using the stiff backward differentiation formula
+ * Adams-Moulton solver from CVODES.
+ *
+ * \p f must define an operator() with the signature as:
+ *   template<typename T_t, typename T_y, typename... T_Args>
+ *   Eigen::Matrix<stan::return_type_t<T_t, T_y, T_Args...>, Eigen::Dynamic, 1>
+ *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
+ *     std::ostream* msgs, const T_Args&... args);
+ *
+ * t is the time, y is the state, msgs is a stream for error messages, and args
+ * are optional arguments passed to the ODE solve function (which are passed
+ * through to \p f without modification).
+ *
+ * @tparam F Type of ODE right hand side
+ * @tparam T_0 Type of initial time
+ * @tparam T_ts Type of output times
+ * @tparam T_Args Types of pass-through parameters
+ *
+ * @param f Right hand side of the ODE
+ * @param y0 Initial state
+ * @param t0 Initial time
+ * @param ts Times at which to solve the ODE at. All values must be sorted and
+ *   not less than t0.
+ * @param relative_tolerance Relative tolerance passed to CVODES
+ * @param absolute_tolerance Absolute tolerance passed to CVODES
+ * @param max_num_steps Upper limit on the number of integration steps to
+ *   take between each output (error if exceeded)
+ * @param[in, out] msgs the print stream for warning messages
+ * @param args Extra arguments passed unmodified through to ODE right hand side
+ * @return Solution to ODE at times \p ts
+ */
+template <typename F, typename T_initial, typename T_t0, typename T_ts,
+          typename... T_Args>
+std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>, Eigen::Dynamic, 1>>
+ode_adams_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+            const T_t0& t0, const std::vector<T_ts>& ts,
+            double relative_tolerance, double absolute_tolerance,
+            long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
+  cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
+      f, y0, t0, ts, relative_tolerance, absolute_tolerance, max_num_steps,
+      msgs, args...);
+
+  return integrator();
+}
+
+/**
+ * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
+ * times, { t1, t2, t3, ... } using the non-stiff Adams-Moulton
+ * solver in CVODES with a relative tolerance of 1e-10, an absolute
+ * tolerance of 1e-10, and taking a maximum of 1e8 steps.
+ *
+ * \p f must define an operator() with the signature as:
+ *   template<typename T_t, typename T_y, typename... T_Args>
+ *   Eigen::Matrix<stan::return_type_t<T_t, T_y, T_Args...>, Eigen::Dynamic, 1>
+ *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
+ *     std::ostream* msgs, const T_Args&... args);
+ *
+ * t is the time, y is the state, msgs is a stream for error messages, and args
+ * are optional arguments passed to the ODE solve function (which are passed
+ * through to \p f without modification).
+ *
+ * @tparam F Type of ODE right hand side
+ * @tparam T_0 Type of initial time
+ * @tparam T_ts Type of output times
+ * @tparam T_Args Types of pass-through parameters
+ *
+ * @param f Right hand side of the ODE
+ * @param y0 Initial state
+ * @param t0 Initial time
+ * @param ts Times at which to solve the ODE at. All values must be sorted and
+ *   not less than t0.
+ * @param relative_tolerance Relative tolerance passed to CVODES
+ * @param absolute_tolerance Absolute tolerance passed to CVODES
+ * @param max_num_steps Upper limit on the number of integration steps to
+ *   take between each output (error if exceeded)
+ * @param[in, out] msgs the print stream for warning messages
+ * @param args Extra arguments passed unmodified through to ODE right hand side
+ * @return Solution to ODE at times \p ts
+ */
+template <typename F, typename T_initial, typename T_t0, typename T_ts,
+          typename... T_Args>
+std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
+                          Eigen::Dynamic, 1>>
+ode_adams(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+        const T_t0& t0, const std::vector<T_ts>& ts, std::ostream* msgs,
+        const T_Args&... args) {
+  double relative_tolerance = 1e-10;
+  double absolute_tolerance = 1e-10;
+  long int max_num_steps = 1e8;
+
+  return ode_adams_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
+                     max_num_steps, msgs, args...);
+}
+
+}  // namespace math
+}  // namespace stan
+#endif
diff --git a/test/unit/math/rev/functor/integrate_ode_adams_prim_test.cpp b/test/unit/math/rev/functor/integrate_ode_adams_prim_test.cpp
index f9babf56361..250d61b0577 100644
--- a/test/unit/math/rev/functor/integrate_ode_adams_prim_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_adams_prim_test.cpp
@@ -356,7 +356,7 @@ TEST(StanMathOde_integrate_ode_adams, error_conditions_bad_ode) {
   std::vector<int> x_int(2, 0);
 
   std::string error_msg
-      = "cvodes_ode_data: dz_dt (3) and states (2) must match in size";
+      = "cvodes_integrator::rhs: dy_dt (3) and states (2) must match in size";
 
   EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta, x, x_int, 0,
                                        1e-8, 1e-10, 1e6),
diff --git a/test/unit/math/rev/functor/integrate_ode_adams_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_adams_rev_test.cpp
index 85805ac2eb9..45e9b542a22 100644
--- a/test/unit/math/rev/functor/integrate_ode_adams_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_adams_rev_test.cpp
@@ -129,7 +129,7 @@ TEST(StanAgradRevOde_integrate_ode_adams, harmonic_oscillator_error) {
 
   // aligned error handling with non-stiff case
   std::string error_msg
-      = "cvodes_ode_data: dz_dt (3) and states (2) must match in size";
+      = "cvodes_integrator: dy_dt (3) and states (2) must match in size";
 
   sho_error_test<double, var>(harm_osc, y0, t0, ts, theta, x, x_int, error_msg);
   sho_error_test<var, double>(harm_osc, y0, t0, ts, theta, x, x_int, error_msg);
@@ -215,7 +215,7 @@ TEST(StanAgradRevOde_integrate_ode_adams, time_steps_as_param_AD) {
           } else {
             std::vector<double> y0(res_d.begin(), res_d.begin() + ns);
             EXPECT_FLOAT_EQ(g[k],
-                            ode(ts[i].val(), y0, theta, x, x_int, msgs)[j]);
+                            ode(ts[i].val(), y0, msgs, theta, x, x_int)[j]);
           }
         }
         stan::math::set_zero_all_adjoints();
@@ -238,42 +238,46 @@ TEST(StanAgradRevOde_integrate_ode_adams, t0_as_param_AD) {
   using stan::math::value_of;
   using stan::math::var;
   const double t0 = 0.0;
-  const int nt = 100;  // nb. of time steps
-  const int ns = 2;    // nb. of states
   std::ostream* msgs = NULL;
 
   harm_osc_ode_fun ode;
 
-  std::vector<double> theta{0.15, 0.25};
+  std::vector<double> theta{0.15};
   std::vector<double> y0{1.0, 0.0};
-  std::vector<double> ts;
-  for (int i = 0; i < nt; i++)
-    ts.push_back(t0 + 0.1 * (i + 1));
+  std::vector<double> ts = {5.0, 10.0};
 
   std::vector<double> x;
   std::vector<int> x_int;
   std::vector<stan::math::var> y0v = to_var(y0);
   std::vector<stan::math::var> thetav = to_var(theta);
-  stan::math::var t0v = 0.0;
+  stan::math::var t0v = to_var(t0);
 
   std::vector<std::vector<stan::math::var> > res;
-  auto test_ad = [&res, &t0v, &ode, &nt, &ns, &theta, &x, &x_int, &msgs]() {
-    for (auto i = 0; i < nt; ++i) {
-      std::vector<double> res_d = value_of(res[i]);
-      res[i][0].grad();
-      EXPECT_FLOAT_EQ(t0v.adj(), 0.0);
-      stan::math::set_zero_all_adjoints();
-      res[i][1].grad();
-      EXPECT_FLOAT_EQ(t0v.adj(), 1.0);
-      stan::math::set_zero_all_adjoints();
-    }
+  auto test_ad = [&res, &t0v, &ode, &theta, &x, &x_int, &msgs]() {
+    res[0][0].grad();
+    EXPECT_FLOAT_EQ(t0v.adj(), -0.66360742442816977871);
+    stan::math::set_zero_all_adjoints();
+    res[0][1].grad();
+    EXPECT_FLOAT_EQ(t0v.adj(), 0.23542843380353062344);
+    stan::math::set_zero_all_adjoints();
+    res[1][0].grad();
+    EXPECT_FLOAT_EQ(t0v.adj(), -0.2464078910913158893);
+    stan::math::set_zero_all_adjoints();
+    res[1][1].grad();
+    EXPECT_FLOAT_EQ(t0v.adj(), -0.38494826636037426937);
+    stan::math::set_zero_all_adjoints();
   };
-  res = integrate_ode_adams(ode, y0, t0v, ts, theta, x, x_int);
+  res = integrate_ode_adams(ode, y0, t0v, ts, theta, x, x_int, nullptr, 1e-10,
+                          1e-10, 1e6);
   test_ad();
-  res = integrate_ode_adams(ode, y0v, t0v, ts, theta, x, x_int);
+  res = integrate_ode_adams(ode, y0v, t0v, ts, theta, x, x_int, nullptr, 1e-10,
+                          1e-10, 1e6);
   test_ad();
-  res = integrate_ode_adams(ode, y0, t0v, ts, thetav, x, x_int);
+  res = integrate_ode_adams(ode, y0, t0v, ts, thetav, x, x_int, nullptr, 1e-10,
+                          1e-10, 1e6);
   test_ad();
-  res = integrate_ode_adams(ode, y0v, t0v, ts, thetav, x, x_int);
+  res = integrate_ode_adams(ode, y0v, t0v, ts, thetav, x, x_int, nullptr, 1e-10,
+                          1e-10, 1e6);
   test_ad();
+  stan::math::recover_memory();
 }
diff --git a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
index ae034f85076..123cfce37f6 100644
--- a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
@@ -131,7 +131,7 @@ TEST(StanAgradRevOde_integrate_ode_bdf, harmonic_oscillator_error) {
 
   // aligned error handling with non-stiff case
   std::string error_msg
-      = "cvodes_integrator::rhs: dy_dt (3) and states (2) must match in size";
+      = "cvodes_integrator: dy_dt (3) and states (2) must match in size";
 
   sho_error_test<double, var>(harm_osc, y0, t0, ts, theta, x, x_int, error_msg);
   sho_error_test<var, double>(harm_osc, y0, t0, ts, theta, x, x_int, error_msg);
@@ -241,8 +241,6 @@ TEST(StanAgradRevOde_integrate_ode_bdf, time_steps_as_param_AD) {
         res[i][j].grad();
         for (auto k = 0; k < nt; ++k) {
           if (k != i) {
-            // std::cout << "setup: i = " << i << ", j = " << j << ", k = " << k
-            // << std::endl;
             EXPECT_FLOAT_EQ(ts[k].adj(), 0.0);
           } else {
             std::vector<double> y0(res_d.begin(), res_d.begin() + ns);

From 8dfa0d1347cf356a4549bbb551c465315216404b Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 25 May 2020 13:26:04 -0400
Subject: [PATCH 126/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 stan/math/rev/functor/cvodes_integrator.hpp   |  4 ++--
 stan/math/rev/functor/integrate_ode_adams.hpp | 22 +++++++++----------
 stan/math/rev/functor/ode_adams.hpp           | 16 ++++++++------
 .../functor/integrate_ode_adams_rev_test.cpp  |  8 +++----
 4 files changed, 26 insertions(+), 24 deletions(-)

diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 5162e524a9e..dbf343f2377 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -106,8 +106,8 @@ class cvodes_integrator {
         = apply([&](auto&&... args) { return f_(t, y_vec, msgs_, args...); },
                 value_of_args_tuple_);
 
-    check_size_match("cvodes_integrator", "dy_dt", dy_dt_vec.size(),
-                     "states", N_);
+    check_size_match("cvodes_integrator", "dy_dt", dy_dt_vec.size(), "states",
+                     N_);
 
     std::copy(dy_dt_vec.data(), dy_dt_vec.data() + dy_dt_vec.size(), dy_dt);
   }
diff --git a/stan/math/rev/functor/integrate_ode_adams.hpp b/stan/math/rev/functor/integrate_ode_adams.hpp
index 1c10b3df68b..f108ef9a7e0 100644
--- a/stan/math/rev/functor/integrate_ode_adams.hpp
+++ b/stan/math/rev/functor/integrate_ode_adams.hpp
@@ -10,23 +10,23 @@ namespace stan {
 namespace math {
 
 /**
-  *  @deprecated use <code>ode_adams</code>
-  */
+ *  @deprecated use <code>ode_adams</code>
+ */
 template <typename F, typename T_initial, typename T_param, typename T_t0,
-        typename T_ts>
+          typename T_ts>
 std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>>
 integrate_ode_adams(const F& f, const std::vector<T_initial>& y0,
-                  const T_t0& t0, const std::vector<T_ts>& ts,
-                  const std::vector<T_param>& theta,
-                  const std::vector<double>& x, const std::vector<int>& x_int,
-                  std::ostream* msgs = nullptr,
-                  double relative_tolerance = 1e-10,
-                  double absolute_tolerance = 1e-10,
-                  long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
+                    const T_t0& t0, const std::vector<T_ts>& ts,
+                    const std::vector<T_param>& theta,
+                    const std::vector<double>& x, const std::vector<int>& x_int,
+                    std::ostream* msgs = nullptr,
+                    double relative_tolerance = 1e-10,
+                    double absolute_tolerance = 1e-10,
+                    long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
   internal::integrate_ode_std_vector_interface_adapter<F> f_adapted(f);
   auto y
       = ode_adams_tol(f_adapted, to_vector(y0), t0, ts, relative_tolerance,
-                    absolute_tolerance, max_num_steps, msgs, theta, x, x_int);
+                      absolute_tolerance, max_num_steps, msgs, theta, x, x_int);
 
   std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>>
       y_converted;
diff --git a/stan/math/rev/functor/ode_adams.hpp b/stan/math/rev/functor/ode_adams.hpp
index 71465593cbe..3450d4bc133 100644
--- a/stan/math/rev/functor/ode_adams.hpp
+++ b/stan/math/rev/functor/ode_adams.hpp
@@ -44,11 +44,13 @@ namespace math {
  */
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
-std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>, Eigen::Dynamic, 1>>
+std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
+                          Eigen::Dynamic, 1>>
 ode_adams_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-            const T_t0& t0, const std::vector<T_ts>& ts,
-            double relative_tolerance, double absolute_tolerance,
-            long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
+              const T_t0& t0, const std::vector<T_ts>& ts,
+              double relative_tolerance, double absolute_tolerance,
+              long int max_num_steps, std::ostream* msgs,
+              const T_Args&... args) {
   cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
       f, y0, t0, ts, relative_tolerance, absolute_tolerance, max_num_steps,
       msgs, args...);
@@ -95,14 +97,14 @@ template <typename F, typename T_initial, typename T_t0, typename T_ts,
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
 ode_adams(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-        const T_t0& t0, const std::vector<T_ts>& ts, std::ostream* msgs,
-        const T_Args&... args) {
+          const T_t0& t0, const std::vector<T_ts>& ts, std::ostream* msgs,
+          const T_Args&... args) {
   double relative_tolerance = 1e-10;
   double absolute_tolerance = 1e-10;
   long int max_num_steps = 1e8;
 
   return ode_adams_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
-                     max_num_steps, msgs, args...);
+                       max_num_steps, msgs, args...);
 }
 
 }  // namespace math
diff --git a/test/unit/math/rev/functor/integrate_ode_adams_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_adams_rev_test.cpp
index 45e9b542a22..0c89dfcf26d 100644
--- a/test/unit/math/rev/functor/integrate_ode_adams_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_adams_rev_test.cpp
@@ -268,16 +268,16 @@ TEST(StanAgradRevOde_integrate_ode_adams, t0_as_param_AD) {
     stan::math::set_zero_all_adjoints();
   };
   res = integrate_ode_adams(ode, y0, t0v, ts, theta, x, x_int, nullptr, 1e-10,
-                          1e-10, 1e6);
+                            1e-10, 1e6);
   test_ad();
   res = integrate_ode_adams(ode, y0v, t0v, ts, theta, x, x_int, nullptr, 1e-10,
-                          1e-10, 1e6);
+                            1e-10, 1e6);
   test_ad();
   res = integrate_ode_adams(ode, y0, t0v, ts, thetav, x, x_int, nullptr, 1e-10,
-                          1e-10, 1e6);
+                            1e-10, 1e6);
   test_ad();
   res = integrate_ode_adams(ode, y0v, t0v, ts, thetav, x, x_int, nullptr, 1e-10,
-                          1e-10, 1e6);
+                            1e-10, 1e6);
   test_ad();
   stan::math::recover_memory();
 }

From b4e89d32dee58547169b3445649ce2ffa1292d53 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 25 May 2020 13:32:07 -0400
Subject: [PATCH 127/189] Added tests for new adams ode interface (design-doc
 #19)

---
 .../math/rev/functor/ode_adams_rev_test.cpp   | 454 ++++++++++++++++++
 1 file changed, 454 insertions(+)
 create mode 100644 test/unit/math/rev/functor/ode_adams_rev_test.cpp

diff --git a/test/unit/math/rev/functor/ode_adams_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
new file mode 100644
index 00000000000..9a2191deffb
--- /dev/null
+++ b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
@@ -0,0 +1,454 @@
+#include <stan/math/rev.hpp>
+#include <boost/numeric/odeint.hpp>
+#include <gtest/gtest.h>
+#include <test/unit/util.hpp>
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <limits>
+#include <string>
+
+using stan::math::var;
+
+template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
+T sum_(T arg) {
+  return arg;
+}
+
+template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
+auto sum_(EigMat&& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
+auto sum_(Vec&& arg) {
+  stan::scalar_type_t<Vec> sum = 0;
+  for (size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
+  }
+  return sum;
+}
+
+struct CosArg1 {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos(sum_(vec) * t);
+    return out;
+  }
+};
+
+struct Cos2Arg {
+  template <typename T0, typename T1, typename T2, typename T3>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a, const T3& b) const {
+    Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos((sum_(a) + sum_(b)) * t);
+    return out;
+  }
+};
+
+TEST(StanMathOde_ode_adams_tol, int_t0) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  int t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
+      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
+  EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
+}
+
+TEST(StanMathOde_ode_adams_tol, int_ts) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<int> ts = {1, 2};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
+      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
+  EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
+}
+
+TEST(StanMathOde_ode_adams_tol, t0) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  var t0 = 0.0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+}
+
+TEST(StanMathOde_ode_adams_tol, ts) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<var> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
+}
+
+TEST(StanMathOde_ode_adams_tol, scalar_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a = 1.5;
+
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_adams_tol, scalar_arg_multi_time) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  var a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0](0).grad();
+
+  EXPECT_FLOAT_EQ(output[0](0).val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(a.adj(), -0.04352005542);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1](0).grad();
+
+  EXPECT_FLOAT_EQ(output[1](0).val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_adams_tol, std_vector_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  std::vector<var> a = {1.5};
+
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a[0].adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_adams_tol, vector_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
+  a << 1.5;
+
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_adams_tol, row_vector_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
+  a << 1.5;
+
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_adams_tol, matrix_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
+  a << 1.5;
+
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0, 0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_adams_tol, scalar_std_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 0.0;
+  std::vector<var> a1 = {1.5};
+
+  var output = stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a0, a1)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
+}
+
+struct ayt {
+  template <typename T0, typename T1, typename T2>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a) const {
+    return -a * y * t;
+  }
+};
+
+TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
+  var t0 = 0.5;
+  var a = 0.2;
+  std::vector<var> ts = {1.25};
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
+  y0 << 0.75;
+
+  double t0d = stan::math::value_of(t0);
+  double ad = stan::math::value_of(a);
+  std::vector<double> tsd = stan::math::value_of(ts);
+  Eigen::VectorXd y0d = stan::math::value_of(y0);
+
+  auto check_yT = [&](auto yT) {
+    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_t0 = [&](var t0) {
+    EXPECT_FLOAT_EQ(
+        t0.adj(),
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_a = [&](var a) {
+    EXPECT_FLOAT_EQ(a.adj(),
+                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_ts = [&](std::vector<var> ts) {
+    EXPECT_FLOAT_EQ(
+        ts[0].adj(),
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
+    EXPECT_FLOAT_EQ(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  double yT1 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                       nullptr, ad)[0](0);
+  check_yT(yT1);
+
+  var yT2 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT2.grad();
+  check_yT(yT2);
+  check_a(a);
+
+  var yT3 = stan::math::ode_adams_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT3.grad();
+  check_yT(yT3);
+  check_ts(ts);
+
+  var yT4 = stan::math::ode_adams_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT4.grad();
+  check_yT(yT4);
+  check_ts(ts);
+  check_a(a);
+
+  var yT5 = stan::math::ode_adams_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT5.grad();
+  check_yT(yT5);
+  check_t0(t0);
+
+  var yT6 = stan::math::ode_adams_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT6.grad();
+  check_yT(yT6);
+  check_t0(t0);
+  check_a(a);
+
+  var yT7 = stan::math::ode_adams_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT7.grad();
+  check_yT(yT7);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT8 = stan::math::ode_adams_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT8.grad();
+  check_yT(yT8);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT9 = stan::math::ode_adams_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT9.grad();
+  check_yT(yT9);
+  check_y0(y0);
+
+  var yT10 = stan::math::ode_adams_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT10.grad();
+  check_yT(yT10);
+  check_y0(y0);
+  check_a(a);
+
+  var yT11 = stan::math::ode_adams_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT11.grad();
+  check_yT(yT11);
+  check_y0(y0);
+  check_ts(ts);
+
+  var yT12 = stan::math::ode_adams_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT12.grad();
+  check_yT(yT12);
+  check_y0(y0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT13 = stan::math::ode_adams_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT13.grad();
+  check_yT(yT13);
+  check_y0(y0);
+  check_t0(t0);
+
+  var yT14 = stan::math::ode_adams_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT14.grad();
+  check_yT(yT14);
+  check_y0(y0);
+  check_t0(t0);
+  check_a(a);
+
+  var yT15 = stan::math::ode_adams_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT15.grad();
+  check_yT(yT15);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT16 = stan::math::ode_adams_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT16.grad();
+  check_yT(yT16);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+}

From a1f928baada1ffe81aedfcaded1e5926457c0f8f Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 25 May 2020 14:39:25 -0400
Subject: [PATCH 128/189] Times to ODE solvers only need to be sorted, not
 strictly increasing (design-doc #19)

---
 stan/math/prim/err.hpp                        |   1 +
 stan/math/prim/err/check_sorted.hpp           |  73 ++++++++++
 stan/math/prim/functor/ode_rk45.hpp           |   6 +-
 stan/math/rev/functor/cvodes_integrator.hpp   |  10 +-
 .../unit/math/prim/err/check_ordered_test.cpp |   3 +
 test/unit/math/prim/err/check_sorted_test.cpp | 128 ++++++++++++++++++
 .../functor/integrate_ode_rk45_prim_test.cpp  |   2 +-
 .../functor/integrate_ode_adams_prim_test.cpp |   4 +-
 .../functor/integrate_ode_bdf_prim_test.cpp   |   4 +-
 .../functor/integrate_ode_rk45_rev_test.cpp   |   2 +-
 .../math/rev/functor/ode_adams_rev_test.cpp   |  40 ++++++
 .../math/rev/functor/ode_bdf_rev_test.cpp     |  40 ++++++
 .../math/rev/functor/ode_rk45_rev_test.cpp    |  40 ++++++
 .../math/rev/functor/util_cvodes_adams.hpp    |   2 +-
 .../unit/math/rev/functor/util_cvodes_bdf.hpp |   2 +-
 .../rev/functor/{util.hpp => util_rk45.hpp}   |   2 +-
 16 files changed, 342 insertions(+), 17 deletions(-)
 create mode 100644 stan/math/prim/err/check_sorted.hpp
 create mode 100644 test/unit/math/prim/err/check_sorted_test.cpp
 rename test/unit/math/rev/functor/{util.hpp => util_rk45.hpp} (99%)

diff --git a/stan/math/prim/err.hpp b/stan/math/prim/err.hpp
index d66a79c41e4..969fcc37fb4 100644
--- a/stan/math/prim/err.hpp
+++ b/stan/math/prim/err.hpp
@@ -28,6 +28,7 @@
 #include <stan/math/prim/err/check_nonzero_size.hpp>
 #include <stan/math/prim/err/check_not_nan.hpp>
 #include <stan/math/prim/err/check_ordered.hpp>
+#include <stan/math/prim/err/check_sorted.hpp>
 #include <stan/math/prim/err/check_pos_definite.hpp>
 #include <stan/math/prim/err/check_pos_semidefinite.hpp>
 #include <stan/math/prim/err/check_positive.hpp>
diff --git a/stan/math/prim/err/check_sorted.hpp b/stan/math/prim/err/check_sorted.hpp
new file mode 100644
index 00000000000..37282b7036b
--- /dev/null
+++ b/stan/math/prim/err/check_sorted.hpp
@@ -0,0 +1,73 @@
+#ifndef STAN_MATH_PRIM_ERR_CHECK_SORTED_HPP
+#define STAN_MATH_PRIM_ERR_CHECK_SORTED_HPP
+
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/err/throw_domain_error.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace stan {
+namespace math {
+
+/**
+ * Check if the specified vector is sorted into increasing order (repeated values are okay).
+ * @tparam T_y Type of scalar
+ * @param function Function name (for error messages)
+ * @param name Variable name (for error messages)
+ * @param y Vector to test
+ * @throw <code>std::domain_error</code> if the vector elements are
+ *   not sorted, or if any element is <code>NaN</code>.
+ */
+template <typename T_y>
+void check_sorted(const char* function, const char* name,
+                   const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y) {
+  using size_type = index_type_t<Eigen::Matrix<T_y, Eigen::Dynamic, 1>>;
+
+  for (size_type n = 1; n < y.size(); n++) {
+    if (!(y[n] >= y[n - 1])) {
+      std::ostringstream msg1;
+      msg1 << "is not a valid sorted vector."
+           << " The element at " << stan::error_index::value + n << " is ";
+      std::string msg1_str(msg1.str());
+      std::ostringstream msg2;
+      msg2 << ", but should be greater than or equal to the previous element, " << y[n - 1];
+      std::string msg2_str(msg2.str());
+      throw_domain_error(function, name, y[n], msg1_str.c_str(),
+                         msg2_str.c_str());
+    }
+  }
+}
+
+/**
+ * Check if the specified vector is sorted into increasing order (repeated values are okay).
+ * @tparam T_y Type of scalar
+ * @param function Function name (for error messages)
+ * @param name Variable name (for error messages)
+ * @param y <code>std::vector</code> to test
+ * @throw <code>std::domain_error</code> if the vector elements are
+ *   not sorted, or if any element
+ *   is <code>NaN</code>.
+ */
+template <typename T_y>
+void check_sorted(const char* function, const char* name,
+                   const std::vector<T_y>& y) {
+  for (size_t n = 1; n < y.size(); n++) {
+    if (!(y[n] >= y[n - 1])) {
+      std::ostringstream msg1;
+      msg1 << "is not a valid sorted vector."
+           << " The element at " << stan::error_index::value + n << " is ";
+      std::string msg1_str(msg1.str());
+      std::ostringstream msg2;
+      msg2 << ", but should be greater than or equal to the previous element, " << y[n - 1];
+      std::string msg2_str(msg2.str());
+      throw_domain_error(function, name, y[n], msg1_str.c_str(),
+                         msg2_str.c_str());
+    }
+  }
+}
+
+}  // namespace math
+}  // namespace stan
+#endif
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index 42c950f0ca6..3ce7a856684 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -40,7 +40,7 @@ namespace math {
  * @param y0 Initial state
  * @param t0 Initial time
  * @param ts Times at which to solve the ODE at. All values must be sorted and
- *   not less than t0.
+ *   greater than t0.
  * @param relative_tolerance Relative tolerance passed to CVODES
  * @param absolute_tolerance Absolute tolerance passed to CVODES
  * @param max_num_steps Upper limit on the number of integration steps to
@@ -80,7 +80,7 @@ ode_rk45_tol(const F& f,
 
   check_nonzero_size("integrate_ode_rk45", "initial state", y0);
   check_nonzero_size("integrate_ode_rk45", "times", ts);
-  check_ordered("integrate_ode_rk45", "times", ts);
+  check_sorted("integrate_ode_rk45", "times", ts);
   check_less("integrate_ode_rk45", "initial time", t0, ts[0]);
 
   if (relative_tolerance <= 0) {
@@ -168,7 +168,7 @@ ode_rk45_tol(const F& f,
  * @param y0 Initial state
  * @param t0 Initial time
  * @param ts Times at which to solve the ODE at. All values must be sorted and
- *   not less than t0.
+ *   greather than t0.
  * @param relative_tolerance Relative tolerance passed to CVODES
  * @param absolute_tolerance Absolute tolerance passed to CVODES
  * @param max_num_steps Upper limit on the number of integration steps to
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 5162e524a9e..bbf434d73f9 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -214,7 +214,7 @@ class cvodes_integrator {
 
     check_nonzero_size(fun, "times", ts_);
     check_nonzero_size(fun, "initial state", y0_);
-    check_ordered(fun, "times", ts_);
+    check_sorted(fun, "times", ts_);
     check_less(fun, "initial time", t0_, ts_[0]);
     check_positive_finite(fun, "relative_tolerance", relative_tolerance_);
     check_positive_finite(fun, "absolute_tolerance", absolute_tolerance_);
@@ -303,11 +303,11 @@ class cvodes_integrator {
           check_flag_sundials(
               CVode(cvodes_mem, t_final, nv_state_, &t_init, CV_NORMAL),
               "CVode");
-        }
 
-        if (y0_vars_ + args_vars_ > 0) {
-          check_flag_sundials(CVodeGetSens(cvodes_mem, &t_init, nv_state_sens_),
-                              "CVodeGetSens");
+	  if (y0_vars_ + args_vars_ > 0) {
+	    check_flag_sundials(CVodeGetSens(cvodes_mem, &t_init, nv_state_sens_),
+				"CVodeGetSens");
+	  }
         }
 
         y.emplace_back(apply(
diff --git a/test/unit/math/prim/err/check_ordered_test.cpp b/test/unit/math/prim/err/check_ordered_test.cpp
index 6ca4a2c70e3..175b2eddf3c 100644
--- a/test/unit/math/prim/err/check_ordered_test.cpp
+++ b/test/unit/math/prim/err/check_ordered_test.cpp
@@ -26,6 +26,9 @@ TEST(ErrorHandling, checkOrdered) {
   y = {0, std::numeric_limits<double>::infinity(),
        std::numeric_limits<double>::infinity()};
   EXPECT_THROW(check_ordered("check_ordered", "y", y), std::domain_error);
+
+  y = { -1, 3, 2 };
+  EXPECT_THROW(check_ordered("check_ordered", "y", y), std::domain_error);
 }
 
 TEST(ErrorHandling, checkOrdered_one_indexed_message) {
diff --git a/test/unit/math/prim/err/check_sorted_test.cpp b/test/unit/math/prim/err/check_sorted_test.cpp
new file mode 100644
index 00000000000..8af7b32c421
--- /dev/null
+++ b/test/unit/math/prim/err/check_sorted_test.cpp
@@ -0,0 +1,128 @@
+#include <stan/math/prim.hpp>
+#include <gtest/gtest.h>
+#include <limits>
+#include <string>
+#include <vector>
+
+using stan::math::check_sorted;
+
+TEST(ErrorHandling, checkSorted) {
+  std::vector<double> y = {0, 1, 2};
+  EXPECT_NO_THROW(check_sorted("check_sorted", "y", y));
+
+  y = {0, 1, std::numeric_limits<double>::infinity()};
+  EXPECT_NO_THROW(check_sorted("check_sorted", "y", y));
+
+  y = {-10, 1, std::numeric_limits<double>::infinity()};
+  EXPECT_NO_THROW(check_sorted("check_sorted", "y", y));
+
+  y = {-std::numeric_limits<double>::infinity(), 1,
+       std::numeric_limits<double>::infinity()};
+  EXPECT_NO_THROW(check_sorted("check_sorted", "y", y));
+
+  y = {0, 0, 0};
+  EXPECT_NO_THROW(check_sorted("check_sorted", "y", y));
+
+  y = {0, std::numeric_limits<double>::infinity(),
+       std::numeric_limits<double>::infinity()};
+  EXPECT_NO_THROW(check_sorted("check_sorted", "y", y));
+
+  y = { -1, 3, 2 };
+  EXPECT_THROW(check_sorted("check_sorted", "y", y), std::domain_error);
+}
+
+TEST(ErrorHandling, checkSorted_one_indexed_message) {
+  std::string message;
+  std::vector<double> y = {0, 5, 1};
+
+  try {
+    check_sorted("check_sorted", "y", y);
+    FAIL() << "should have thrown";
+  } catch (std::domain_error& e) {
+    message = e.what();
+  } catch (...) {
+    FAIL() << "threw the wrong error";
+  }
+
+  EXPECT_NE(std::string::npos, message.find("element at 3")) << message;
+}
+
+TEST(ErrorHandling, checkSorted_nan) {
+  double nan = std::numeric_limits<double>::quiet_NaN();
+  std::vector<double> y = {0, 1, 2};
+
+  for (size_t i = 0; i < y.size(); i++) {
+    y[i] = nan;
+    EXPECT_THROW(check_sorted("check_sorted", "y", y), std::domain_error);
+    y[i] = i;
+  }
+  for (size_t i = 0; i < y.size(); i++) {
+    y = {0.0, 10.0, std::numeric_limits<double>::infinity()};
+    y[i] = nan;
+    EXPECT_THROW(check_sorted("check_sorted", "y", y), std::domain_error);
+  }
+}
+
+TEST(ErrorHandlingMatrix, checkSorted) {
+  Eigen::Matrix<double, Eigen::Dynamic, 1> y;
+  y.resize(3);
+
+  y << 0, 1, 2;
+  EXPECT_NO_THROW(check_sorted("check_sorted", "y", y));
+
+  y << 0, 10, std::numeric_limits<double>::infinity();
+  EXPECT_NO_THROW(check_sorted("check_sorted", "y", y));
+
+  y << -10, 10, std::numeric_limits<double>::infinity();
+  EXPECT_NO_THROW(check_sorted("check_sorted", "y", y));
+
+  y << -std::numeric_limits<double>::infinity(), 10,
+      std::numeric_limits<double>::infinity();
+  EXPECT_NO_THROW(check_sorted("check_sorted", "y", y));
+
+  y << 0, 0, 0;
+  EXPECT_NO_THROW(check_sorted("check_sorted", "y", y));
+
+  y << 0, std::numeric_limits<double>::infinity(),
+      std::numeric_limits<double>::infinity();
+  EXPECT_NO_THROW(check_sorted("check_sorted", "y", y));
+
+  y << -1, 3, 2;
+  EXPECT_THROW(check_sorted("check_sorted", "y", y), std::domain_error);
+}
+
+TEST(ErrorHandlingMatrix, checkSorted_one_indexed_message) {
+  std::string message;
+  Eigen::Matrix<double, Eigen::Dynamic, 1> y;
+  y.resize(3);
+
+  y << 0, 5, 1;
+  try {
+    check_sorted("check_sorted", "y", y);
+    FAIL() << "should have thrown";
+  } catch (std::domain_error& e) {
+    message = e.what();
+  } catch (...) {
+    FAIL() << "threw the wrong error";
+  }
+
+  EXPECT_NE(std::string::npos, message.find("element at 3")) << message;
+}
+
+TEST(ErrorHandlingMatrix, checkSorted_nan) {
+  Eigen::Matrix<double, Eigen::Dynamic, 1> y;
+  double nan = std::numeric_limits<double>::quiet_NaN();
+  y.resize(3);
+
+  y << 0, 1, 2;
+  for (int i = 0; i < y.size(); i++) {
+    y[i] = nan;
+    EXPECT_THROW(check_sorted("check_sorted", "y", y), std::domain_error);
+    y[i] = i;
+  }
+  for (int i = 0; i < y.size(); i++) {
+    y << 0, 10, std::numeric_limits<double>::infinity();
+    y[i] = nan;
+    EXPECT_THROW(check_sorted("check_sorted", "y", y), std::domain_error);
+  }
+}
diff --git a/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp b/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
index 1368701a1c9..d7a5a50dc0a 100644
--- a/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
+++ b/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
@@ -121,7 +121,7 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions) {
   ts_bad.push_back(1);
   EXPECT_THROW_MSG(
       (integrate_ode_rk45(harm_osc, y0, t0, ts_bad, theta, x, x_int)),
-      std::domain_error, "times is not a valid ordered vector");
+      std::domain_error, "times is not a valid sorted vector");
 
   std::vector<double> theta_bad;
   EXPECT_THROW_MSG(
diff --git a/test/unit/math/rev/functor/integrate_ode_adams_prim_test.cpp b/test/unit/math/rev/functor/integrate_ode_adams_prim_test.cpp
index 250d61b0577..7a6743f9224 100644
--- a/test/unit/math/rev/functor/integrate_ode_adams_prim_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_adams_prim_test.cpp
@@ -117,7 +117,7 @@ TEST(StanMathOde_integrate_ode_adams, error_conditions) {
   ts_bad.push_back(1);
   EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts_bad, theta, x,
                                        x_int, 0, 1e-8, 1e-10, 1e6),
-                   std::domain_error, "times is not a valid ordered vector");
+                   std::domain_error, "times is not a valid sorted vector");
 
   // TODO(carpenter): g++6 failure
   std::vector<double> theta_bad;
@@ -356,7 +356,7 @@ TEST(StanMathOde_integrate_ode_adams, error_conditions_bad_ode) {
   std::vector<int> x_int(2, 0);
 
   std::string error_msg
-      = "cvodes_integrator::rhs: dy_dt (3) and states (2) must match in size";
+      = "cvodes_integrator: dy_dt (3) and states (2) must match in size";
 
   EXPECT_THROW_MSG(integrate_ode_adams(harm_osc, y0, t0, ts, theta, x, x_int, 0,
                                        1e-8, 1e-10, 1e6),
diff --git a/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp
index 89bcca946e8..e29ba7eaf5f 100644
--- a/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_bdf_prim_test.cpp
@@ -116,7 +116,7 @@ TEST(StanMathOde_integrate_ode_bdf, error_conditions) {
   ts_bad.push_back(1);
   EXPECT_THROW_MSG(integrate_ode_bdf(harm_osc, y0, t0, ts_bad, theta, x, x_int,
                                      0, 1e-8, 1e-10, 1e6),
-                   std::domain_error, "times is not a valid ordered vector");
+                   std::domain_error, "times is not a valid sorted vector");
 
   // TODO(carpenter): g++6 failure
   std::vector<double> theta_bad;
@@ -355,7 +355,7 @@ TEST(StanMathOde_integrate_ode_bdf, error_conditions_bad_ode) {
   std::vector<int> x_int(2, 0);
 
   std::string error_msg
-      = "cvodes_integrator::rhs: dy_dt (3) and states (2) must match in size";
+      = "cvodes_integrator: dy_dt (3) and states (2) must match in size";
 
   EXPECT_THROW_MSG(integrate_ode_bdf(harm_osc, y0, t0, ts, theta, x, x_int, 0,
                                      1e-8, 1e-10, 1e6),
diff --git a/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
index f64006d140e..3ef7fa9d5ee 100644
--- a/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
@@ -1,7 +1,7 @@
 #include <stan/math/rev.hpp>
 #include <gtest/gtest.h>
 #include <boost/numeric/odeint.hpp>
-#include <test/unit/math/rev/functor/util.hpp>
+#include <test/unit/math/rev/functor/util_rk45.hpp>
 #include <test/unit/math/prim/functor/harmonic_oscillator.hpp>
 #include <test/unit/math/prim/functor/forced_harmonic_oscillator.hpp>
 #include <test/unit/math/prim/functor/lorenz.hpp>
diff --git a/test/unit/math/rev/functor/ode_adams_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
index 9a2191deffb..252f71c3058 100644
--- a/test/unit/math/rev/functor/ode_adams_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
@@ -87,6 +87,46 @@ TEST(StanMathOde_ode_adams_tol, int_ts) {
   EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
 }
 
+TEST(StanMathOde_ode_adams_tol, ts_repeat) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<var> ts = {0.45, 0.45, 1.1, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[1].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+  
+  output[2][0].grad();
+
+  EXPECT_FLOAT_EQ(output[2][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[2].adj(), -0.0791208888);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[3][0].grad();
+
+  EXPECT_FLOAT_EQ(output[3][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[3].adj(), -0.0791208888);
+}
+
 TEST(StanMathOde_ode_adams_tol, t0) {
   using stan::math::var;
 
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index 5e6e477f455..157af23bd0c 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -139,6 +139,46 @@ TEST(StanMathOde_ode_bdf_tol, ts) {
   EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
 }
 
+TEST(StanMathOde_ode_bdf_tol, ts_repeat) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<var> ts = {0.45, 0.45, 1.1, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[1].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+  
+  output[2][0].grad();
+
+  EXPECT_FLOAT_EQ(output[2][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[2].adj(), -0.0791208888);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[3][0].grad();
+
+  EXPECT_FLOAT_EQ(output[3][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[3].adj(), -0.0791208888);
+}
+
 TEST(StanMathOde_ode_bdf_tol, scalar_arg) {
   using stan::math::var;
 
diff --git a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
index 384a95a20dc..35ccd74eaf5 100644
--- a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
@@ -142,6 +142,46 @@ TEST(StanMathOde_ode_rk45_tol, ts) {
   EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
 }
 
+TEST(StanMathOde_ode_rk45_tol, ts_repeat) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<var> ts = {0.45, 0.45, 1.1, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[1].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+  
+  output[2][0].grad();
+
+  EXPECT_FLOAT_EQ(output[2][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[2].adj(), -0.0791208888);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[3][0].grad();
+
+  EXPECT_FLOAT_EQ(output[3][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[3].adj(), -0.0791208888);
+}
+
 TEST(StanMathOde_ode_rk45_tol, scalar_arg) {
   using stan::math::var;
 
diff --git a/test/unit/math/rev/functor/util_cvodes_adams.hpp b/test/unit/math/rev/functor/util_cvodes_adams.hpp
index e772330ced8..14622ea9bb6 100644
--- a/test/unit/math/rev/functor/util_cvodes_adams.hpp
+++ b/test/unit/math/rev/functor/util_cvodes_adams.hpp
@@ -274,7 +274,7 @@ void test_ode_error_conditions(F& f, const double& t0,
   ts_bad.push_back(1);
   EXPECT_THROW_MSG(integrate_ode_adams(f, y0, t0, ts_bad, theta, x, x_int,
                                        &msgs, 1e-8, 1e-10, 1e6),
-                   std::domain_error, "times is not a valid ordered vector");
+                   std::domain_error, "times is not a valid sorted vector");
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
diff --git a/test/unit/math/rev/functor/util_cvodes_bdf.hpp b/test/unit/math/rev/functor/util_cvodes_bdf.hpp
index 9bd6e7f4453..fb97b1ff0e0 100644
--- a/test/unit/math/rev/functor/util_cvodes_bdf.hpp
+++ b/test/unit/math/rev/functor/util_cvodes_bdf.hpp
@@ -278,7 +278,7 @@ void test_ode_error_conditions(F& f, const double& t0,
   ts_bad.push_back(1);
   EXPECT_THROW_MSG(integrate_ode_bdf(f, y0, t0, ts_bad, theta, x, x_int, &msgs,
                                      1e-8, 1e-10, 1e6),
-                   std::domain_error, "times is not a valid ordered vector");
+                   std::domain_error, "times is not a valid sorted vector");
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();
diff --git a/test/unit/math/rev/functor/util.hpp b/test/unit/math/rev/functor/util_rk45.hpp
similarity index 99%
rename from test/unit/math/rev/functor/util.hpp
rename to test/unit/math/rev/functor/util_rk45.hpp
index 26a537ec7b3..23a73de66b0 100644
--- a/test/unit/math/rev/functor/util.hpp
+++ b/test/unit/math/rev/functor/util_rk45.hpp
@@ -272,7 +272,7 @@ void test_ode_error_conditions(F& f, const double& t0,
   ts_bad.push_back(1);
   EXPECT_THROW_MSG(
       (integrate_ode_rk45(f, y0, t0, ts_bad, theta, x, x_int, &msgs)),
-      std::domain_error, "times is not a valid ordered vector");
+      std::domain_error, "times is not a valid sorted vector");
   EXPECT_EQ("", msgs.str());
 
   msgs.clear();

From ae99813581abe37fd921abfb2dbdd48ee7b91202 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 25 May 2020 19:08:00 +0000
Subject: [PATCH 129/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

---
 stan/math/prim/err/check_sorted.hpp           | 16 +++--
 stan/math/rev/functor/cvodes_integrator.hpp   |  9 +--
 .../unit/math/prim/err/check_ordered_test.cpp |  2 +-
 test/unit/math/prim/err/check_sorted_test.cpp |  2 +-
 .../math/rev/functor/ode_adams_rev_test.cpp   | 72 +++++++++----------
 .../math/rev/functor/ode_bdf_rev_test.cpp     |  2 +-
 .../math/rev/functor/ode_rk45_rev_test.cpp    |  4 +-
 7 files changed, 56 insertions(+), 51 deletions(-)

diff --git a/stan/math/prim/err/check_sorted.hpp b/stan/math/prim/err/check_sorted.hpp
index 37282b7036b..93a6be2321b 100644
--- a/stan/math/prim/err/check_sorted.hpp
+++ b/stan/math/prim/err/check_sorted.hpp
@@ -12,7 +12,8 @@ namespace stan {
 namespace math {
 
 /**
- * Check if the specified vector is sorted into increasing order (repeated values are okay).
+ * Check if the specified vector is sorted into increasing order (repeated
+ * values are okay).
  * @tparam T_y Type of scalar
  * @param function Function name (for error messages)
  * @param name Variable name (for error messages)
@@ -22,7 +23,7 @@ namespace math {
  */
 template <typename T_y>
 void check_sorted(const char* function, const char* name,
-                   const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y) {
+                  const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y) {
   using size_type = index_type_t<Eigen::Matrix<T_y, Eigen::Dynamic, 1>>;
 
   for (size_type n = 1; n < y.size(); n++) {
@@ -32,7 +33,8 @@ void check_sorted(const char* function, const char* name,
            << " The element at " << stan::error_index::value + n << " is ";
       std::string msg1_str(msg1.str());
       std::ostringstream msg2;
-      msg2 << ", but should be greater than or equal to the previous element, " << y[n - 1];
+      msg2 << ", but should be greater than or equal to the previous element, "
+           << y[n - 1];
       std::string msg2_str(msg2.str());
       throw_domain_error(function, name, y[n], msg1_str.c_str(),
                          msg2_str.c_str());
@@ -41,7 +43,8 @@ void check_sorted(const char* function, const char* name,
 }
 
 /**
- * Check if the specified vector is sorted into increasing order (repeated values are okay).
+ * Check if the specified vector is sorted into increasing order (repeated
+ * values are okay).
  * @tparam T_y Type of scalar
  * @param function Function name (for error messages)
  * @param name Variable name (for error messages)
@@ -52,7 +55,7 @@ void check_sorted(const char* function, const char* name,
  */
 template <typename T_y>
 void check_sorted(const char* function, const char* name,
-                   const std::vector<T_y>& y) {
+                  const std::vector<T_y>& y) {
   for (size_t n = 1; n < y.size(); n++) {
     if (!(y[n] >= y[n - 1])) {
       std::ostringstream msg1;
@@ -60,7 +63,8 @@ void check_sorted(const char* function, const char* name,
            << " The element at " << stan::error_index::value + n << " is ";
       std::string msg1_str(msg1.str());
       std::ostringstream msg2;
-      msg2 << ", but should be greater than or equal to the previous element, " << y[n - 1];
+      msg2 << ", but should be greater than or equal to the previous element, "
+           << y[n - 1];
       std::string msg2_str(msg2.str());
       throw_domain_error(function, name, y[n], msg1_str.c_str(),
                          msg2_str.c_str());
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 1406c73053b..1d71bc1b952 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -304,10 +304,11 @@ class cvodes_integrator {
               CVode(cvodes_mem, t_final, nv_state_, &t_init, CV_NORMAL),
               "CVode");
 
-	  if (y0_vars_ + args_vars_ > 0) {
-	    check_flag_sundials(CVodeGetSens(cvodes_mem, &t_init, nv_state_sens_),
-				"CVodeGetSens");
-	  }
+          if (y0_vars_ + args_vars_ > 0) {
+            check_flag_sundials(
+                CVodeGetSens(cvodes_mem, &t_init, nv_state_sens_),
+                "CVodeGetSens");
+          }
         }
 
         y.emplace_back(apply(
diff --git a/test/unit/math/prim/err/check_ordered_test.cpp b/test/unit/math/prim/err/check_ordered_test.cpp
index 175b2eddf3c..c56534178c1 100644
--- a/test/unit/math/prim/err/check_ordered_test.cpp
+++ b/test/unit/math/prim/err/check_ordered_test.cpp
@@ -27,7 +27,7 @@ TEST(ErrorHandling, checkOrdered) {
        std::numeric_limits<double>::infinity()};
   EXPECT_THROW(check_ordered("check_ordered", "y", y), std::domain_error);
 
-  y = { -1, 3, 2 };
+  y = {-1, 3, 2};
   EXPECT_THROW(check_ordered("check_ordered", "y", y), std::domain_error);
 }
 
diff --git a/test/unit/math/prim/err/check_sorted_test.cpp b/test/unit/math/prim/err/check_sorted_test.cpp
index 8af7b32c421..7cdfed74ee4 100644
--- a/test/unit/math/prim/err/check_sorted_test.cpp
+++ b/test/unit/math/prim/err/check_sorted_test.cpp
@@ -27,7 +27,7 @@ TEST(ErrorHandling, checkSorted) {
        std::numeric_limits<double>::infinity()};
   EXPECT_NO_THROW(check_sorted("check_sorted", "y", y));
 
-  y = { -1, 3, 2 };
+  y = {-1, 3, 2};
   EXPECT_THROW(check_sorted("check_sorted", "y", y), std::domain_error);
 }
 
diff --git a/test/unit/math/rev/functor/ode_adams_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
index 252f71c3058..89a2bdc0ec4 100644
--- a/test/unit/math/rev/functor/ode_adams_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
@@ -64,7 +64,7 @@ TEST(StanMathOde_ode_adams_tol, int_t0) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                  nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
   EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
@@ -81,7 +81,7 @@ TEST(StanMathOde_ode_adams_tol, int_ts) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                  nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
   EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
@@ -98,7 +98,7 @@ TEST(StanMathOde_ode_adams_tol, ts_repeat) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                  nullptr, a);
 
   output[0][0].grad();
 
@@ -113,7 +113,7 @@ TEST(StanMathOde_ode_adams_tol, ts_repeat) {
   EXPECT_FLOAT_EQ(ts[1].adj(), 0.78070695113);
 
   stan::math::set_zero_all_adjoints();
-  
+
   output[2][0].grad();
 
   EXPECT_FLOAT_EQ(output[2][0].val(), 0.66457668563);
@@ -138,7 +138,7 @@ TEST(StanMathOde_ode_adams_tol, t0) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                  nullptr, a);
 
   output[0][0].grad();
 
@@ -164,7 +164,7 @@ TEST(StanMathOde_ode_adams_tol, ts) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                  nullptr, a);
 
   output[0][0].grad();
 
@@ -188,8 +188,8 @@ TEST(StanMathOde_ode_adams_tol, scalar_arg) {
 
   var a = 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -208,7 +208,7 @@ TEST(StanMathOde_ode_adams_tol, scalar_arg_multi_time) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                  nullptr, a);
 
   output[0](0).grad();
 
@@ -232,8 +232,8 @@ TEST(StanMathOde_ode_adams_tol, std_vector_arg) {
 
   std::vector<var> a = {1.5};
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -251,8 +251,8 @@ TEST(StanMathOde_ode_adams_tol, vector_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -270,8 +270,8 @@ TEST(StanMathOde_ode_adams_tol, row_vector_arg) {
   Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -289,8 +289,8 @@ TEST(StanMathOde_ode_adams_tol, matrix_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
   a << 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -308,8 +308,8 @@ TEST(StanMathOde_ode_adams_tol, scalar_std_vector_args) {
   var a0 = 0.0;
   std::vector<var> a1 = {1.5};
 
-  var output = stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a0, a1)[0][0];
+  var output = stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a0, a1)[0][0];
 
   output.grad();
 
@@ -366,26 +366,26 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
                     exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
-  double yT1 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                       nullptr, ad)[0](0);
+  double yT1 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                         1e6, nullptr, ad)[0](0);
   check_yT(yT1);
 
   var yT2 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
   var yT3 = stan::math::ode_adams_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
   var yT4 = stan::math::ode_adams_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
@@ -393,14 +393,14 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT5 = stan::math::ode_adams_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
   var yT6 = stan::math::ode_adams_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
@@ -408,7 +408,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT7 = stan::math::ode_adams_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
@@ -416,7 +416,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_ts(ts);
 
   var yT8 = stan::math::ode_adams_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -425,14 +425,14 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT9 = stan::math::ode_adams_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
   var yT10 = stan::math::ode_adams_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                       nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
@@ -440,7 +440,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT11 = stan::math::ode_adams_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                       nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
@@ -448,7 +448,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_ts(ts);
 
   var yT12 = stan::math::ode_adams_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                       nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -457,7 +457,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT13 = stan::math::ode_adams_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                       nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
@@ -465,7 +465,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_t0(t0);
 
   var yT14 = stan::math::ode_adams_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                       nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -474,7 +474,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT15 = stan::math::ode_adams_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                       nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -483,7 +483,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_ts(ts);
 
   var yT16 = stan::math::ode_adams_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                       nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index 157af23bd0c..6c7b272aa56 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -165,7 +165,7 @@ TEST(StanMathOde_ode_bdf_tol, ts_repeat) {
   EXPECT_FLOAT_EQ(ts[1].adj(), 0.78070695113);
 
   stan::math::set_zero_all_adjoints();
-  
+
   output[2][0].grad();
 
   EXPECT_FLOAT_EQ(output[2][0].val(), 0.66457668563);
diff --git a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
index 35ccd74eaf5..f14e9fe5590 100644
--- a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
@@ -153,7 +153,7 @@ TEST(StanMathOde_ode_rk45_tol, ts_repeat) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                 nullptr, a);
 
   output[0][0].grad();
 
@@ -168,7 +168,7 @@ TEST(StanMathOde_ode_rk45_tol, ts_repeat) {
   EXPECT_FLOAT_EQ(ts[1].adj(), 0.78070695113);
 
   stan::math::set_zero_all_adjoints();
-  
+
   output[2][0].grad();
 
   EXPECT_FLOAT_EQ(output[2][0].val(), 0.66457668563);

From ea303ffb4c625ef604067da625f44eff71b9f386 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Thu, 28 May 2020 14:41:47 -0400
Subject: [PATCH 130/189] Added new prim tests for bdf solver. Added new
 interfaces that include sensitivity in error analysis and include optional
 relative and absolute error tolerances of sensitivities (design-doc #19)

---
 stan/math/rev/functor/cvodes_integrator.hpp   |  32 +-
 stan/math/rev/functor/ode_adams.hpp           |  31 +-
 stan/math/rev/functor/ode_bdf.hpp             |  33 +-
 .../math/rev/functor/ode_adams_rev_test.cpp   | 346 +++++++++++++++++
 .../math/rev/functor/ode_bdf_prim_test.cpp    | 358 ++++++++++++++++++
 .../math/rev/functor/ode_bdf_rev_test.cpp     | 351 ++++++++++++++++-
 6 files changed, 1142 insertions(+), 9 deletions(-)
 create mode 100644 test/unit/math/rev/functor/ode_bdf_prim_test.cpp

diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 1d71bc1b952..2a4201ee6d4 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -43,6 +43,7 @@ class cvodes_integrator {
   std::ostream* msgs_;
   double relative_tolerance_;
   double absolute_tolerance_;
+  bool include_sensitivities_in_errors_;
   long int max_num_steps_;
 
   const size_t y0_vars_;
@@ -180,6 +181,7 @@ class cvodes_integrator {
                     const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
                     const T_t0& t0, const std::vector<T_ts>& ts,
                     double relative_tolerance, double absolute_tolerance,
+		    bool include_sensitivities_in_errors,
                     long int max_num_steps, std::ostream* msgs,
                     const T_Args&... args)
       : f_(f),
@@ -192,6 +194,7 @@ class cvodes_integrator {
         msgs_(msgs),
         relative_tolerance_(relative_tolerance),
         absolute_tolerance_(absolute_tolerance),
+	include_sensitivities_in_errors_(include_sensitivities_in_errors),
         max_num_steps_(max_num_steps),
         y0_vars_(count_vars(y0_)),
         args_vars_(count_vars(args...)),
@@ -252,7 +255,12 @@ class cvodes_integrator {
    *   solution time (excluding the initial state)
    */
   std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>>
-  operator()() {  // NOLINT(runtime/int)
+  operator()() {
+    return (*this)(0.0, {});
+  }
+
+  std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>>
+  operator()(double rtols, std::vector<double> atols) {
     std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> y;
 
     void* cvodes_mem = CVodeCreate(Lmm);
@@ -272,7 +280,7 @@ class cvodes_integrator {
 
       cvodes_set_options(cvodes_mem, relative_tolerance_, absolute_tolerance_,
                          max_num_steps_);
-
+      
       // for the stiff solvers we need to reserve additional memory
       // and provide a Jacobian function call. new API since 3.0.0:
       // create matrix object and linear solver object; resource
@@ -291,8 +299,24 @@ class cvodes_integrator {
                           nv_state_sens_),
             "CVodeSensInit");
 
-        check_flag_sundials(CVodeSensEEtolerances(cvodes_mem),
-                            "CVodeSensEEtolerances");
+	if(include_sensitivities_in_errors_) {
+	  check_flag_sundials(CVodeSetSensErrCon(cvodes_mem, SUNTRUE),
+			      "CVodeSetSensErrCon");
+	} else {
+	  check_flag_sundials(CVodeSetSensErrCon(cvodes_mem, SUNFALSE),
+			      "CVodeSetSensErrCon");
+	}
+
+	if(atols.size() > 0) {
+	  check_positive_finite("cvodes_integrator", "sensitivity relative_tolerance", rtols);
+	  check_size_match("cvodes_interator", "atols.size()", atols.size(), "number of sensitivities", y0_vars_ + args_vars_);
+	  check_positive_finite("cvodes_integrator", "sensitivity absolute_tolerance", atols);
+	  check_flag_sundials(CVodeSensSStolerances(cvodes_mem, rtols, atols.data()),
+			  "CVodeSensSStolerances");
+	} else {
+	  check_flag_sundials(CVodeSensEEtolerances(cvodes_mem),
+			      "CVodeSensEEtolerances");
+	}
       }
 
       double t_init = value_of(t0_);
diff --git a/stan/math/rev/functor/ode_adams.hpp b/stan/math/rev/functor/ode_adams.hpp
index 3450d4bc133..ea2a2ef52ee 100644
--- a/stan/math/rev/functor/ode_adams.hpp
+++ b/stan/math/rev/functor/ode_adams.hpp
@@ -8,6 +8,35 @@
 
 namespace stan {
 namespace math {
+template <typename F, typename T_initial, typename T_t0, typename T_ts,
+          typename... T_Args>
+std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
+                          Eigen::Dynamic, 1>>
+ode_adams_tol_sens_error(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+	     const T_t0& t0, const std::vector<T_ts>& ts,
+	     double rtol, double atol,
+	     double rtols, const std::vector<double>& atols,
+	     long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
+  cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
+									    f, y0, t0, ts, rtol, atol, true, max_num_steps,
+      msgs, args...);
+  
+  return integrator(rtols, atols);
+}
+
+template <typename F, typename T_initial, typename T_t0, typename T_ts,
+          typename... T_Args>
+std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
+                          Eigen::Dynamic, 1>>
+ode_adams_tol_error(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+	     const T_t0& t0, const std::vector<T_ts>& ts,
+	     double relative_tolerance, double absolute_tolerance,
+	     long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
+  cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(f, y0, t0, ts, relative_tolerance, absolute_tolerance, true, max_num_steps,
+      msgs, args...);
+
+  return integrator();
+}
 
 /**
  * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
@@ -52,7 +81,7 @@ ode_adams_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
               long int max_num_steps, std::ostream* msgs,
               const T_Args&... args) {
   cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
-      f, y0, t0, ts, relative_tolerance, absolute_tolerance, max_num_steps,
+									      f, y0, t0, ts, relative_tolerance, absolute_tolerance, false, max_num_steps,
       msgs, args...);
 
   return integrator();
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index f0021dcb358..0ae0a00a0e4 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -9,6 +9,36 @@
 namespace stan {
 namespace math {
 
+template <typename F, typename T_initial, typename T_t0, typename T_ts,
+          typename... T_Args>
+std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
+                          Eigen::Dynamic, 1>>
+ode_bdf_tol_sens_error(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+	     const T_t0& t0, const std::vector<T_ts>& ts,
+	     double rtol, double atol,
+	     double rtols, const std::vector<double>& atols,
+	     long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
+  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
+									    f, y0, t0, ts, rtol, atol, true, max_num_steps,
+      msgs, args...);
+  
+  return integrator(rtols, atols);
+}
+
+template <typename F, typename T_initial, typename T_t0, typename T_ts,
+          typename... T_Args>
+std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
+                          Eigen::Dynamic, 1>>
+ode_bdf_tol_error(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+	     const T_t0& t0, const std::vector<T_ts>& ts,
+	     double relative_tolerance, double absolute_tolerance,
+	     long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
+  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(f, y0, t0, ts, relative_tolerance, absolute_tolerance, true, max_num_steps,
+      msgs, args...);
+
+  return integrator();
+}
+
 /**
  * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
  * times, { t1, t2, t3, ... } using the stiff backward differentiation formula
@@ -50,8 +80,7 @@ ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
             const T_t0& t0, const std::vector<T_ts>& ts,
             double relative_tolerance, double absolute_tolerance,
             long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
-  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
-      f, y0, t0, ts, relative_tolerance, absolute_tolerance, max_num_steps,
+  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(f, y0, t0, ts, relative_tolerance, absolute_tolerance, false, max_num_steps,
       msgs, args...);
 
   return integrator();
diff --git a/test/unit/math/rev/functor/ode_adams_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
index 89a2bdc0ec4..ccf58ae5e42 100644
--- a/test/unit/math/rev/functor/ode_adams_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
@@ -492,3 +492,349 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 }
+
+TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
+  var t0 = 0.5;
+  var a = 0.2;
+  std::vector<var> ts = {1.25};
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
+  y0 << 0.75;
+
+  double t0d = stan::math::value_of(t0);
+  double ad = stan::math::value_of(a);
+  std::vector<double> tsd = stan::math::value_of(ts);
+  Eigen::VectorXd y0d = stan::math::value_of(y0);
+
+  auto check_yT = [&](auto yT) {
+    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_t0 = [&](var t0) {
+    EXPECT_FLOAT_EQ(
+        t0.adj(),
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_a = [&](var a) {
+    EXPECT_FLOAT_EQ(a.adj(),
+                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_ts = [&](std::vector<var> ts) {
+    EXPECT_FLOAT_EQ(
+        ts[0].adj(),
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
+    EXPECT_FLOAT_EQ(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  double yT1 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                       nullptr, ad)[0](0);
+  check_yT(yT1);
+
+  var yT2 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT2.grad();
+  check_yT(yT2);
+  check_a(a);
+
+  var yT3 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT3.grad();
+  check_yT(yT3);
+  check_ts(ts);
+
+  var yT4 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT4.grad();
+  check_yT(yT4);
+  check_ts(ts);
+  check_a(a);
+
+  var yT5 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT5.grad();
+  check_yT(yT5);
+  check_t0(t0);
+
+  var yT6 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT6.grad();
+  check_yT(yT6);
+  check_t0(t0);
+  check_a(a);
+
+  var yT7 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT7.grad();
+  check_yT(yT7);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT8 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT8.grad();
+  check_yT(yT8);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT9 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT9.grad();
+  check_yT(yT9);
+  check_y0(y0);
+
+  var yT10 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT10.grad();
+  check_yT(yT10);
+  check_y0(y0);
+  check_a(a);
+
+  var yT11 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT11.grad();
+  check_yT(yT11);
+  check_y0(y0);
+  check_ts(ts);
+
+  var yT12 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT12.grad();
+  check_yT(yT12);
+  check_y0(y0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT13 = stan::math::ode_adams_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT13.grad();
+  check_yT(yT13);
+  check_y0(y0);
+  check_t0(t0);
+
+  var yT14 = stan::math::ode_adams_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT14.grad();
+  check_yT(yT14);
+  check_y0(y0);
+  check_t0(t0);
+  check_a(a);
+
+  var yT15 = stan::math::ode_adams_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT15.grad();
+  check_yT(yT15);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT16 = stan::math::ode_adams_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT16.grad();
+  check_yT(yT16);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+}
+
+TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
+  var t0 = 0.5;
+  var a = 0.2;
+  std::vector<var> ts = {1.25};
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
+  y0 << 0.75;
+
+  double t0d = stan::math::value_of(t0);
+  double ad = stan::math::value_of(a);
+  std::vector<double> tsd = stan::math::value_of(ts);
+  Eigen::VectorXd y0d = stan::math::value_of(y0);
+
+  auto check_yT = [&](auto yT) {
+    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_t0 = [&](var t0) {
+    EXPECT_FLOAT_EQ(
+        t0.adj(),
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_a = [&](var a) {
+    EXPECT_FLOAT_EQ(a.adj(),
+                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_ts = [&](std::vector<var> ts) {
+    EXPECT_FLOAT_EQ(
+        ts[0].adj(),
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
+    EXPECT_FLOAT_EQ(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  double yT1 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {}, 1e6,
+                                       nullptr, ad)[0](0);
+  check_yT(yT1);
+
+  var yT2 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT2.grad();
+  check_yT(yT2);
+  check_a(a);
+
+  var yT3 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {}, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT3.grad();
+  check_yT(yT3);
+  check_ts(ts);
+
+  var yT4 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT4.grad();
+  check_yT(yT4);
+  check_ts(ts);
+  check_a(a);
+
+  var yT5 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT5.grad();
+  check_yT(yT5);
+  check_t0(t0);
+
+  var yT6 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT6.grad();
+  check_yT(yT6);
+  check_t0(t0);
+  check_a(a);
+
+  var yT7 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT7.grad();
+  check_yT(yT7);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT8 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT8.grad();
+  check_yT(yT8);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT9 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT9.grad();
+  check_yT(yT9);
+  check_y0(y0);
+
+  var yT10 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT10.grad();
+  check_yT(yT10);
+  check_y0(y0);
+  check_a(a);
+
+  var yT11 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT11.grad();
+  check_yT(yT11);
+  check_y0(y0);
+  check_ts(ts);
+
+  var yT12 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT12.grad();
+  check_yT(yT12);
+  check_y0(y0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT13 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT13.grad();
+  check_yT(yT13);
+  check_y0(y0);
+  check_t0(t0);
+
+  var yT14 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT14.grad();
+  check_yT(yT14);
+  check_y0(y0);
+  check_t0(t0);
+  check_a(a);
+
+  var yT15 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT15.grad();
+  check_yT(yT15);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT16 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT16.grad();
+  check_yT(yT16);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+
+  EXPECT_THROW(stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
+						  nullptr, a),
+						  std::invalid_argument);
+
+  EXPECT_THROW(stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, -1e-6, { 1e-6 }, 1e6,
+						  nullptr, a),
+						  std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, -1e-6, { -1e-6 }, 1e6,
+						  nullptr, a),
+						  std::domain_error);
+}
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
new file mode 100644
index 00000000000..b3b805d0928
--- /dev/null
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -0,0 +1,358 @@
+#include <stan/math/rev.hpp>
+#include <boost/numeric/odeint.hpp>
+#include <gtest/gtest.h>
+#include <test/unit/util.hpp>
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <limits>
+#include <string>
+
+using stan::math::var;
+
+template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
+T sum_(T arg) {
+  return arg;
+}
+
+template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
+auto sum_(EigMat&& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
+auto sum_(Vec&& arg) {
+  stan::scalar_type_t<Vec> sum = 0;
+  for (size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
+  }
+  return sum;
+}
+
+struct CosArg1 {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos(sum_(vec) * t);
+    return out;
+  }
+};
+
+struct Cos2Arg {
+  template <typename T0, typename T1, typename T2, typename T3>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a, const T3& b) const {
+    Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos((sum_(a) + sum_(b)) * t);
+    return out;
+  }
+};
+
+struct CosArgWrongSize {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(2);
+    out << stan::math::cos(sum_(vec) * t), 0;
+    return out;
+  }
+};
+
+TEST(ode_bdf_prim, y0_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  Eigen::VectorXd y0inf(1);
+  Eigen::VectorXd y0NaN(1);
+  Eigen::VectorXd y0_empty;
+  y0NaN << stan::math::NOT_A_NUMBER;
+  y0inf << stan::math::INFTY;
+  int t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+					  nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0inf, t0, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, a),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0NaN, t0, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, a),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0_empty, t0, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, a),
+	       std::invalid_argument);
+}
+
+TEST(ode_bdf_prim, t0_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  double t0inf = stan::math::INFTY;
+  double t0NaN = stan::math::NOT_A_NUMBER;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+					  nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0inf, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, a),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0NaN, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, a),
+	       std::domain_error);
+}
+
+TEST(ode_bdf_prim, ts_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = { 0.45, 1.1 };
+  std::vector<double> ts_repeat = { 0.45, 0.45 };
+  std::vector<double> ts_empty = { };
+  std::vector<double> ts_early = { -0.45, 0.2 };
+  std::vector<double> ts_decreasing = { 0.45, 0.2 };
+  std::vector<double> tsinf = { stan::math::INFTY, 1.1 };
+  std::vector<double> tsNaN = { 0.45, stan::math::NOT_A_NUMBER };
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+					  nullptr, a));
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_repeat, 1e-10, 1e-10, 1e6,
+					  nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_empty, 1e-10, 1e-10, 1e6,
+				       nullptr, a),
+	       std::invalid_argument);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_early, 1e-10, 1e-10, 1e6,
+				       nullptr, a),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_decreasing, 1e-10, 1e-10, 1e6,
+				       nullptr, a),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, tsinf, 1e-10, 1e-10, 1e6,
+				       nullptr, a),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, tsNaN, 1e-10, 1e-10, 1e6,
+				       nullptr, a),
+	       std::domain_error);
+}
+
+TEST(ode_bdf_prim, one_arg_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = { 0.45, 1.1 };
+
+  double a = 1.5;
+  double ainf = stan::math::INFTY;
+  double aNaN = stan::math::NOT_A_NUMBER;
+
+  std::vector<double> va = { a };
+  std::vector<double> vainf = { ainf };
+  std::vector<double> vaNaN = { aNaN };
+
+  Eigen::VectorXd ea(1);
+  ea << a;
+  Eigen::VectorXd eainf(1);
+  eainf << ainf;
+  Eigen::VectorXd eaNaN(1);
+  eaNaN << aNaN;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+					  nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, ainf),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, aNaN),
+	       std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+					  nullptr, va));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, vainf),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, vaNaN),
+	       std::domain_error);
+  
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+					  nullptr, ea));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, eainf),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, eaNaN),
+	       std::domain_error);
+}
+
+TEST(ode_bdf_prim, two_arg_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = { 0.45, 1.1 };
+
+  double a = 1.5;
+  double ainf = stan::math::INFTY;
+  double aNaN = stan::math::NOT_A_NUMBER;
+
+  std::vector<double> va = { a };
+  std::vector<double> vainf = { ainf };
+  std::vector<double> vaNaN = { aNaN };
+
+  Eigen::VectorXd ea(1);
+  ea << a;
+  Eigen::VectorXd eainf(1);
+  eainf << ainf;
+  Eigen::VectorXd eaNaN(1);
+  eaNaN << aNaN;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+					  nullptr, a, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, a, ainf),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, a, aNaN),
+	       std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+					  nullptr, a, va));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, a, vainf),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, a, vaNaN),
+	       std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+					  nullptr, a, ea));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, a, eainf),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+				       nullptr, a, eaNaN),
+	       std::domain_error);
+}
+
+TEST(ode_bdf_prim, rtol_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double rtol = 1e-6;
+  double rtol_negative = -1e-6;
+  double rtolinf = stan::math::INFTY;
+  double rtolNaN = stan::math::NOT_A_NUMBER;
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtol, 1e-10, 1e6,
+					  nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtol_negative, 1e-10, 1e6,
+				       nullptr, a),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtolinf, 1e-10, 1e6,
+				       nullptr, a),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtolNaN, 1e-10, 1e6,
+				       nullptr, a),
+	       std::domain_error);
+}
+
+TEST(ode_bdf_prim, atol_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double atol = 1e-6;
+  double atol_negative = -1e-6;
+  double atolinf = stan::math::INFTY;
+  double atolNaN = stan::math::NOT_A_NUMBER;
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atol, 1e6,
+					  nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atol_negative, 1e6,
+				       nullptr, a),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atolinf, 1e6,
+				       nullptr, a),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atolNaN, 1e6,
+				       nullptr, a),
+	       std::domain_error);
+}
+
+TEST(ode_bdf_prim, max_num_steps_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  int max_num_steps = 500;
+  int max_num_steps_negative = -500;
+  int max_num_steps_zero = 0;
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6, max_num_steps,
+					  nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6, max_num_steps_negative,
+				       nullptr, a),
+	       std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6, max_num_steps_zero,
+				       nullptr, a),
+	       std::domain_error);
+}
+
+TEST(ode_bdf_prim, rhs_wrong_size_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6, 100,
+					  nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArgWrongSize(), y0, t0, ts, 1e-6, 1e-6, 100,
+				       nullptr, a),
+	       std::invalid_argument);
+}
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index 6c7b272aa56..dc9e6a757f6 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -305,8 +305,8 @@ TEST(StanMathOde_ode_bdf_tol, scalar_std_vector_args) {
   double t0 = 0.0;
   std::vector<double> ts = {1.1};
 
-  var a0 = 0.0;
-  std::vector<var> a1 = {1.5};
+  var a0 = 0.75;
+  std::vector<var> a1 = {0.75};
 
   var output = stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
                                        nullptr, a0, a1)[0][0];
@@ -314,6 +314,7 @@ TEST(StanMathOde_ode_bdf_tol, scalar_std_vector_args) {
   output.grad();
 
   EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a0.adj(), -0.50107310888);
   EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
 }
 
@@ -492,3 +493,349 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 }
+
+TEST(StanMathOde_ode_bdf_tol, arg_combos_error_test) {
+  var t0 = 0.5;
+  var a = 0.2;
+  std::vector<var> ts = {1.25};
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
+  y0 << 0.75;
+
+  double t0d = stan::math::value_of(t0);
+  double ad = stan::math::value_of(a);
+  std::vector<double> tsd = stan::math::value_of(ts);
+  Eigen::VectorXd y0d = stan::math::value_of(y0);
+
+  auto check_yT = [&](auto yT) {
+    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_t0 = [&](var t0) {
+    EXPECT_FLOAT_EQ(
+        t0.adj(),
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_a = [&](var a) {
+    EXPECT_FLOAT_EQ(a.adj(),
+                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_ts = [&](std::vector<var> ts) {
+    EXPECT_FLOAT_EQ(
+        ts[0].adj(),
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
+    EXPECT_FLOAT_EQ(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  double yT1 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                       nullptr, ad)[0](0);
+  check_yT(yT1);
+
+  var yT2 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT2.grad();
+  check_yT(yT2);
+  check_a(a);
+
+  var yT3 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT3.grad();
+  check_yT(yT3);
+  check_ts(ts);
+
+  var yT4 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT4.grad();
+  check_yT(yT4);
+  check_ts(ts);
+  check_a(a);
+
+  var yT5 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT5.grad();
+  check_yT(yT5);
+  check_t0(t0);
+
+  var yT6 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT6.grad();
+  check_yT(yT6);
+  check_t0(t0);
+  check_a(a);
+
+  var yT7 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT7.grad();
+  check_yT(yT7);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT8 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT8.grad();
+  check_yT(yT8);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT9 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT9.grad();
+  check_yT(yT9);
+  check_y0(y0);
+
+  var yT10 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT10.grad();
+  check_yT(yT10);
+  check_y0(y0);
+  check_a(a);
+
+  var yT11 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT11.grad();
+  check_yT(yT11);
+  check_y0(y0);
+  check_ts(ts);
+
+  var yT12 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT12.grad();
+  check_yT(yT12);
+  check_y0(y0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT13 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT13.grad();
+  check_yT(yT13);
+  check_y0(y0);
+  check_t0(t0);
+
+  var yT14 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT14.grad();
+  check_yT(yT14);
+  check_y0(y0);
+  check_t0(t0);
+  check_a(a);
+
+  var yT15 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT15.grad();
+  check_yT(yT15);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT16 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT16.grad();
+  check_yT(yT16);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+}
+
+TEST(StanMathOde_ode_bdf_tol, arg_combos_sens_error_test) {
+  var t0 = 0.5;
+  var a = 0.2;
+  std::vector<var> ts = {1.25};
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
+  y0 << 0.75;
+
+  double t0d = stan::math::value_of(t0);
+  double ad = stan::math::value_of(a);
+  std::vector<double> tsd = stan::math::value_of(ts);
+  Eigen::VectorXd y0d = stan::math::value_of(y0);
+
+  auto check_yT = [&](auto yT) {
+    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_t0 = [&](var t0) {
+    EXPECT_FLOAT_EQ(
+        t0.adj(),
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_a = [&](var a) {
+    EXPECT_FLOAT_EQ(a.adj(),
+                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_ts = [&](std::vector<var> ts) {
+    EXPECT_FLOAT_EQ(
+        ts[0].adj(),
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
+    EXPECT_FLOAT_EQ(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  double yT1 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {}, 1e6,
+                                       nullptr, ad)[0](0);
+  check_yT(yT1);
+
+  var yT2 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT2.grad();
+  check_yT(yT2);
+  check_a(a);
+
+  var yT3 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {}, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT3.grad();
+  check_yT(yT3);
+  check_ts(ts);
+
+  var yT4 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT4.grad();
+  check_yT(yT4);
+  check_ts(ts);
+  check_a(a);
+
+  var yT5 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT5.grad();
+  check_yT(yT5);
+  check_t0(t0);
+
+  var yT6 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT6.grad();
+  check_yT(yT6);
+  check_t0(t0);
+  check_a(a);
+
+  var yT7 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT7.grad();
+  check_yT(yT7);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT8 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT8.grad();
+  check_yT(yT8);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT9 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT9.grad();
+  check_yT(yT9);
+  check_y0(y0);
+
+  var yT10 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT10.grad();
+  check_yT(yT10);
+  check_y0(y0);
+  check_a(a);
+
+  var yT11 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT11.grad();
+  check_yT(yT11);
+  check_y0(y0);
+  check_ts(ts);
+
+  var yT12 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT12.grad();
+  check_yT(yT12);
+  check_y0(y0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT13 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT13.grad();
+  check_yT(yT13);
+  check_y0(y0);
+  check_t0(t0);
+
+  var yT14 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT14.grad();
+  check_yT(yT14);
+  check_y0(y0);
+  check_t0(t0);
+  check_a(a);
+
+  var yT15 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT15.grad();
+  check_yT(yT15);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT16 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT16.grad();
+  check_yT(yT16);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
+						  nullptr, a),
+						  std::invalid_argument);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, -1e-6, { 1e-6 }, 1e6,
+						  nullptr, a),
+						  std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, -1e-6, { -1e-6 }, 1e6,
+						  nullptr, a),
+						  std::domain_error);
+}

From c982322145467f2868f0557d0afb9c52251f9e7d Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Thu, 28 May 2020 14:43:31 -0400
Subject: [PATCH 131/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 stan/math/rev/functor/cvodes_integrator.hpp   |  53 ++--
 stan/math/rev/functor/ode_adams.hpp           |  36 +--
 stan/math/rev/functor/ode_bdf.hpp             |  36 +--
 .../math/rev/functor/ode_adams_rev_test.cpp   | 155 ++++++-----
 .../math/rev/functor/ode_bdf_prim_test.cpp    | 250 +++++++++---------
 .../math/rev/functor/ode_bdf_rev_test.cpp     | 147 +++++-----
 6 files changed, 353 insertions(+), 324 deletions(-)

diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 2a4201ee6d4..7a0ccd0651b 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -181,7 +181,7 @@ class cvodes_integrator {
                     const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
                     const T_t0& t0, const std::vector<T_ts>& ts,
                     double relative_tolerance, double absolute_tolerance,
-		    bool include_sensitivities_in_errors,
+                    bool include_sensitivities_in_errors,
                     long int max_num_steps, std::ostream* msgs,
                     const T_Args&... args)
       : f_(f),
@@ -194,7 +194,7 @@ class cvodes_integrator {
         msgs_(msgs),
         relative_tolerance_(relative_tolerance),
         absolute_tolerance_(absolute_tolerance),
-	include_sensitivities_in_errors_(include_sensitivities_in_errors),
+        include_sensitivities_in_errors_(include_sensitivities_in_errors),
         max_num_steps_(max_num_steps),
         y0_vars_(count_vars(y0_)),
         args_vars_(count_vars(args...)),
@@ -254,13 +254,12 @@ class cvodes_integrator {
    * @return std::vector of Eigen::Matrix of the states of the ODE, one for each
    *   solution time (excluding the initial state)
    */
-  std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>>
-  operator()() {
+  std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> operator()() {
     return (*this)(0.0, {});
   }
 
-  std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>>
-  operator()(double rtols, std::vector<double> atols) {
+  std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> operator()(
+      double rtols, std::vector<double> atols) {
     std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> y;
 
     void* cvodes_mem = CVodeCreate(Lmm);
@@ -280,7 +279,7 @@ class cvodes_integrator {
 
       cvodes_set_options(cvodes_mem, relative_tolerance_, absolute_tolerance_,
                          max_num_steps_);
-      
+
       // for the stiff solvers we need to reserve additional memory
       // and provide a Jacobian function call. new API since 3.0.0:
       // create matrix object and linear solver object; resource
@@ -299,24 +298,28 @@ class cvodes_integrator {
                           nv_state_sens_),
             "CVodeSensInit");
 
-	if(include_sensitivities_in_errors_) {
-	  check_flag_sundials(CVodeSetSensErrCon(cvodes_mem, SUNTRUE),
-			      "CVodeSetSensErrCon");
-	} else {
-	  check_flag_sundials(CVodeSetSensErrCon(cvodes_mem, SUNFALSE),
-			      "CVodeSetSensErrCon");
-	}
-
-	if(atols.size() > 0) {
-	  check_positive_finite("cvodes_integrator", "sensitivity relative_tolerance", rtols);
-	  check_size_match("cvodes_interator", "atols.size()", atols.size(), "number of sensitivities", y0_vars_ + args_vars_);
-	  check_positive_finite("cvodes_integrator", "sensitivity absolute_tolerance", atols);
-	  check_flag_sundials(CVodeSensSStolerances(cvodes_mem, rtols, atols.data()),
-			  "CVodeSensSStolerances");
-	} else {
-	  check_flag_sundials(CVodeSensEEtolerances(cvodes_mem),
-			      "CVodeSensEEtolerances");
-	}
+        if (include_sensitivities_in_errors_) {
+          check_flag_sundials(CVodeSetSensErrCon(cvodes_mem, SUNTRUE),
+                              "CVodeSetSensErrCon");
+        } else {
+          check_flag_sundials(CVodeSetSensErrCon(cvodes_mem, SUNFALSE),
+                              "CVodeSetSensErrCon");
+        }
+
+        if (atols.size() > 0) {
+          check_positive_finite("cvodes_integrator",
+                                "sensitivity relative_tolerance", rtols);
+          check_size_match("cvodes_interator", "atols.size()", atols.size(),
+                           "number of sensitivities", y0_vars_ + args_vars_);
+          check_positive_finite("cvodes_integrator",
+                                "sensitivity absolute_tolerance", atols);
+          check_flag_sundials(
+              CVodeSensSStolerances(cvodes_mem, rtols, atols.data()),
+              "CVodeSensSStolerances");
+        } else {
+          check_flag_sundials(CVodeSensEEtolerances(cvodes_mem),
+                              "CVodeSensEEtolerances");
+        }
       }
 
       double t_init = value_of(t0_);
diff --git a/stan/math/rev/functor/ode_adams.hpp b/stan/math/rev/functor/ode_adams.hpp
index ea2a2ef52ee..15beb0a11af 100644
--- a/stan/math/rev/functor/ode_adams.hpp
+++ b/stan/math/rev/functor/ode_adams.hpp
@@ -12,15 +12,16 @@ template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
-ode_adams_tol_sens_error(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-	     const T_t0& t0, const std::vector<T_ts>& ts,
-	     double rtol, double atol,
-	     double rtols, const std::vector<double>& atols,
-	     long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
+ode_adams_tol_sens_error(const F& f,
+                         const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+                         const T_t0& t0, const std::vector<T_ts>& ts,
+                         double rtol, double atol, double rtols,
+                         const std::vector<double>& atols,
+                         long int max_num_steps, std::ostream* msgs,
+                         const T_Args&... args) {
   cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
-									    f, y0, t0, ts, rtol, atol, true, max_num_steps,
-      msgs, args...);
-  
+      f, y0, t0, ts, rtol, atol, true, max_num_steps, msgs, args...);
+
   return integrator(rtols, atols);
 }
 
@@ -28,12 +29,15 @@ template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
-ode_adams_tol_error(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-	     const T_t0& t0, const std::vector<T_ts>& ts,
-	     double relative_tolerance, double absolute_tolerance,
-	     long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
-  cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(f, y0, t0, ts, relative_tolerance, absolute_tolerance, true, max_num_steps,
-      msgs, args...);
+ode_adams_tol_error(const F& f,
+                    const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+                    const T_t0& t0, const std::vector<T_ts>& ts,
+                    double relative_tolerance, double absolute_tolerance,
+                    long int max_num_steps, std::ostream* msgs,
+                    const T_Args&... args) {
+  cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
+      f, y0, t0, ts, relative_tolerance, absolute_tolerance, true,
+      max_num_steps, msgs, args...);
 
   return integrator();
 }
@@ -81,8 +85,8 @@ ode_adams_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
               long int max_num_steps, std::ostream* msgs,
               const T_Args&... args) {
   cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
-									      f, y0, t0, ts, relative_tolerance, absolute_tolerance, false, max_num_steps,
-      msgs, args...);
+      f, y0, t0, ts, relative_tolerance, absolute_tolerance, false,
+      max_num_steps, msgs, args...);
 
   return integrator();
 }
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 0ae0a00a0e4..7f16b35c417 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -13,15 +13,15 @@ template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
-ode_bdf_tol_sens_error(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-	     const T_t0& t0, const std::vector<T_ts>& ts,
-	     double rtol, double atol,
-	     double rtols, const std::vector<double>& atols,
-	     long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
+ode_bdf_tol_sens_error(const F& f,
+                       const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+                       const T_t0& t0, const std::vector<T_ts>& ts, double rtol,
+                       double atol, double rtols,
+                       const std::vector<double>& atols, long int max_num_steps,
+                       std::ostream* msgs, const T_Args&... args) {
   cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
-									    f, y0, t0, ts, rtol, atol, true, max_num_steps,
-      msgs, args...);
-  
+      f, y0, t0, ts, rtol, atol, true, max_num_steps, msgs, args...);
+
   return integrator(rtols, atols);
 }
 
@@ -29,12 +29,15 @@ template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
-ode_bdf_tol_error(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-	     const T_t0& t0, const std::vector<T_ts>& ts,
-	     double relative_tolerance, double absolute_tolerance,
-	     long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
-  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(f, y0, t0, ts, relative_tolerance, absolute_tolerance, true, max_num_steps,
-      msgs, args...);
+ode_bdf_tol_error(const F& f,
+                  const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+                  const T_t0& t0, const std::vector<T_ts>& ts,
+                  double relative_tolerance, double absolute_tolerance,
+                  long int max_num_steps, std::ostream* msgs,
+                  const T_Args&... args) {
+  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
+      f, y0, t0, ts, relative_tolerance, absolute_tolerance, true,
+      max_num_steps, msgs, args...);
 
   return integrator();
 }
@@ -80,8 +83,9 @@ ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
             const T_t0& t0, const std::vector<T_ts>& ts,
             double relative_tolerance, double absolute_tolerance,
             long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
-  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(f, y0, t0, ts, relative_tolerance, absolute_tolerance, false, max_num_steps,
-      msgs, args...);
+  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
+      f, y0, t0, ts, relative_tolerance, absolute_tolerance, false,
+      max_num_steps, msgs, args...);
 
   return integrator();
 }
diff --git a/test/unit/math/rev/functor/ode_adams_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
index ccf58ae5e42..04dc320f886 100644
--- a/test/unit/math/rev/functor/ode_adams_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
@@ -533,57 +533,57 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
                     exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
-  double yT1 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                       nullptr, ad)[0](0);
+  double yT1 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, tsd, 1e-10,
+                                               1e-10, 1e6, nullptr, ad)[0](0);
   check_yT(yT1);
 
-  var yT2 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+  var yT2 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                            1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
-  var yT3 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+  var yT3 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
+                                            1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
-  var yT4 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+  var yT4 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
+                                            1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
   check_ts(ts);
   check_a(a);
 
-  var yT5 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+  var yT5 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
+                                            1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
-  var yT6 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+  var yT6 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
+                                            1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
   check_t0(t0);
   check_a(a);
 
-  var yT7 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+  var yT7 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10,
+                                            1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
   check_t0(t0);
   check_ts(ts);
 
-  var yT8 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+  var yT8 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10,
+                                            1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -591,31 +591,31 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT9 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+  var yT9 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
+                                            1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
-  var yT10 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+  var yT10 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
+                                             1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
   check_y0(y0);
   check_a(a);
 
-  var yT11 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+  var yT11 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
+                                             1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
   check_y0(y0);
   check_ts(ts);
 
-  var yT12 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+  var yT12 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
+                                             1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -623,16 +623,16 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT13 = stan::math::ode_adams_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+  var yT13 = stan::math::ode_adams_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
+                                             1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
   check_y0(y0);
   check_t0(t0);
 
-  var yT14 = stan::math::ode_adams_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+  var yT14 = stan::math::ode_adams_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
+                                             1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -640,8 +640,8 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
   check_t0(t0);
   check_a(a);
 
-  var yT15 = stan::math::ode_adams_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+  var yT15 = stan::math::ode_adams_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10,
+                                             1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -649,8 +649,8 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
   check_t0(t0);
   check_ts(ts);
 
-  var yT16 = stan::math::ode_adams_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+  var yT16 = stan::math::ode_adams_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10,
+                                             1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
@@ -700,57 +700,59 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
                     exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
-  double yT1 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {}, 1e6,
-                                       nullptr, ad)[0](0);
+  double yT1 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {}, 1e6, nullptr, ad)[0](0);
   check_yT(yT1);
 
-  var yT2 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
-                                    nullptr, a)[0](0);
+  var yT2 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
-  var yT3 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {}, 1e6,
-                                    nullptr, ad)[0](0);
+  var yT3 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {}, 1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
-  var yT4 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
-                                    nullptr, a)[0](0);
+  var yT4 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
   check_ts(ts);
   check_a(a);
 
-  var yT5 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
-                                    nullptr, ad)[0](0);
+  var yT5 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
-  var yT6 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
-                                    nullptr, a)[0](0);
+  var yT6 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10,
+                                                 1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
+                                                 nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
   check_t0(t0);
   check_a(a);
 
-  var yT7 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
-                                    nullptr, ad)[0](0);
+  var yT7 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
   check_t0(t0);
   check_ts(ts);
 
-  var yT8 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
-                                    nullptr, a)[0](0);
+  var yT8 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, ts, 1e-10,
+                                                 1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
+                                                 nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -758,31 +760,33 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT9 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
-                                    nullptr, ad)[0](0);
+  var yT9 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
-  var yT10 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
-                                     nullptr, a)[0](0);
+  var yT10 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10,
+                                                  1e-10, 1e-6, {1e-6, 1e-6},
+                                                  1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
   check_y0(y0);
   check_a(a);
 
-  var yT11 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
-                                     nullptr, ad)[0](0);
+  var yT11 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
   check_y0(y0);
   check_ts(ts);
 
-  var yT12 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
-                                     nullptr, a)[0](0);
+  var yT12 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, ts, 1e-10,
+                                                  1e-10, 1e-6, {1e-6, 1e-6},
+                                                  1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -790,16 +794,17 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT13 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
-                                     nullptr, ad)[0](0);
+  var yT13 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
   check_y0(y0);
   check_t0(t0);
 
-  var yT14 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
-                                     nullptr, a)[0](0);
+  var yT14 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, tsd, 1e-10,
+                                                  1e-10, 1e-6, {1e-6, 1e-6},
+                                                  1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -807,8 +812,8 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_t0(t0);
   check_a(a);
 
-  var yT15 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
-                                     nullptr, ad)[0](0);
+  var yT15 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0, t0, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -816,8 +821,9 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_t0(t0);
   check_ts(ts);
 
-  var yT16 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
-                                     nullptr, a)[0](0);
+  var yT16 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, ts, 1e-10,
+                                                  1e-10, 1e-6, {1e-6, 1e-6},
+                                                  1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
@@ -826,15 +832,18 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_ts(ts);
   check_a(a);
 
-  EXPECT_THROW(stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
-						  nullptr, a),
-						  std::invalid_argument);
+  EXPECT_THROW(
+      stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                           1e-6, {1e-6, 1e-6}, 1e6, nullptr, a),
+      std::invalid_argument);
 
-  EXPECT_THROW(stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, -1e-6, { 1e-6 }, 1e6,
-						  nullptr, a),
-						  std::domain_error);
+  EXPECT_THROW(
+      stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                           -1e-6, {1e-6}, 1e6, nullptr, a),
+      std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, -1e-6, { -1e-6 }, 1e6,
-						  nullptr, a),
-						  std::domain_error);
+  EXPECT_THROW(
+      stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                           -1e-6, {-1e-6}, 1e6, nullptr, a),
+      std::domain_error);
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index b3b805d0928..81fa71affa2 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -78,20 +78,20 @@ TEST(ode_bdf_prim, y0_errors) {
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-					  nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0inf, t0, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, a),
-	       std::domain_error);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0inf, t0, ts, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0NaN, t0, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, a),
-	       std::domain_error);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0NaN, t0, ts, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0_empty, t0, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, a),
-	       std::invalid_argument);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0_empty, t0, ts, 1e-10,
+                                       1e-10, 1e6, nullptr, a),
+               std::invalid_argument);
 }
 
 TEST(ode_bdf_prim, t0_errors) {
@@ -103,70 +103,70 @@ TEST(ode_bdf_prim, t0_errors) {
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-					  nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0inf, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, a),
-	       std::domain_error);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0inf, ts, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0NaN, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, a),
-	       std::domain_error);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0NaN, ts, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
 }
 
 TEST(ode_bdf_prim, ts_errors) {
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0;
-  std::vector<double> ts = { 0.45, 1.1 };
-  std::vector<double> ts_repeat = { 0.45, 0.45 };
-  std::vector<double> ts_empty = { };
-  std::vector<double> ts_early = { -0.45, 0.2 };
-  std::vector<double> ts_decreasing = { 0.45, 0.2 };
-  std::vector<double> tsinf = { stan::math::INFTY, 1.1 };
-  std::vector<double> tsNaN = { 0.45, stan::math::NOT_A_NUMBER };
+  std::vector<double> ts = {0.45, 1.1};
+  std::vector<double> ts_repeat = {0.45, 0.45};
+  std::vector<double> ts_empty = {};
+  std::vector<double> ts_early = {-0.45, 0.2};
+  std::vector<double> ts_decreasing = {0.45, 0.2};
+  std::vector<double> tsinf = {stan::math::INFTY, 1.1};
+  std::vector<double> tsNaN = {0.45, stan::math::NOT_A_NUMBER};
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-					  nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a));
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_repeat, 1e-10, 1e-10, 1e6,
-					  nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
+                                          1e-10, 1e6, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_empty, 1e-10, 1e-10, 1e6,
-				       nullptr, a),
-	       std::invalid_argument);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
+                                       1e-10, 1e6, nullptr, a),
+               std::invalid_argument);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_early, 1e-10, 1e-10, 1e6,
-				       nullptr, a),
-	       std::domain_error);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_early, 1e-10,
+                                       1e-10, 1e6, nullptr, a),
+               std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_decreasing, 1e-10, 1e-10, 1e6,
-				       nullptr, a),
-	       std::domain_error);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_decreasing, 1e-10,
+                                       1e-10, 1e6, nullptr, a),
+               std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, tsinf, 1e-10, 1e-10, 1e6,
-				       nullptr, a),
-	       std::domain_error);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, tsinf, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, tsNaN, 1e-10, 1e-10, 1e6,
-				       nullptr, a),
-	       std::domain_error);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, tsNaN, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
 }
 
 TEST(ode_bdf_prim, one_arg_errors) {
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0;
-  std::vector<double> ts = { 0.45, 1.1 };
+  std::vector<double> ts = {0.45, 1.1};
 
   double a = 1.5;
   double ainf = stan::math::INFTY;
   double aNaN = stan::math::NOT_A_NUMBER;
 
-  std::vector<double> va = { a };
-  std::vector<double> vainf = { ainf };
-  std::vector<double> vaNaN = { aNaN };
+  std::vector<double> va = {a};
+  std::vector<double> vainf = {ainf};
+  std::vector<double> vaNaN = {aNaN};
 
   Eigen::VectorXd ea(1);
   ea << a;
@@ -175,52 +175,52 @@ TEST(ode_bdf_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-					  nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, ainf),
-	       std::domain_error);
+                                       nullptr, ainf),
+               std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, aNaN),
-	       std::domain_error);
+                                       nullptr, aNaN),
+               std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-					  nullptr, va));
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, va));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, vainf),
-	       std::domain_error);
+                                       nullptr, vainf),
+               std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, vaNaN),
-	       std::domain_error);
-  
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-					  nullptr, ea));
+                                       nullptr, vaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, ea));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, eainf),
-	       std::domain_error);
+                                       nullptr, eainf),
+               std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, eaNaN),
-	       std::domain_error);
+                                       nullptr, eaNaN),
+               std::domain_error);
 }
 
 TEST(ode_bdf_prim, two_arg_errors) {
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0;
-  std::vector<double> ts = { 0.45, 1.1 };
+  std::vector<double> ts = {0.45, 1.1};
 
   double a = 1.5;
   double ainf = stan::math::INFTY;
   double aNaN = stan::math::NOT_A_NUMBER;
 
-  std::vector<double> va = { a };
-  std::vector<double> vainf = { ainf };
-  std::vector<double> vaNaN = { aNaN };
+  std::vector<double> va = {a};
+  std::vector<double> vainf = {ainf};
+  std::vector<double> vaNaN = {aNaN};
 
   Eigen::VectorXd ea(1);
   ea << a;
@@ -229,38 +229,38 @@ TEST(ode_bdf_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-					  nullptr, a, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a, a));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, a, ainf),
-	       std::domain_error);
+                                       nullptr, a, ainf),
+               std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, a, aNaN),
-	       std::domain_error);
+                                       nullptr, a, aNaN),
+               std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-					  nullptr, a, va));
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a, va));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, a, vainf),
-	       std::domain_error);
+                                       nullptr, a, vainf),
+               std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, a, vaNaN),
-	       std::domain_error);
+                                       nullptr, a, vaNaN),
+               std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-					  nullptr, a, ea));
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a, ea));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, a, eainf),
-	       std::domain_error);
+                                       nullptr, a, eainf),
+               std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-				       nullptr, a, eaNaN),
-	       std::domain_error);
+                                       nullptr, a, eaNaN),
+               std::domain_error);
 }
 
 TEST(ode_bdf_prim, rtol_errors) {
@@ -275,20 +275,20 @@ TEST(ode_bdf_prim, rtol_errors) {
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtol, 1e-10, 1e6,
-					  nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtol, 1e-10,
+                                          1e6, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtol_negative, 1e-10, 1e6,
-				       nullptr, a),
-	       std::domain_error);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtol_negative,
+                                       1e-10, 1e6, nullptr, a),
+               std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtolinf, 1e-10, 1e6,
-				       nullptr, a),
-	       std::domain_error);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtolinf, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtolNaN, 1e-10, 1e6,
-				       nullptr, a),
-	       std::domain_error);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtolNaN, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
 }
 
 TEST(ode_bdf_prim, atol_errors) {
@@ -303,20 +303,20 @@ TEST(ode_bdf_prim, atol_errors) {
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atol, 1e6,
-					  nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atol,
+                                          1e6, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atol_negative, 1e6,
-				       nullptr, a),
-	       std::domain_error);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6,
+                                       atol_negative, 1e6, nullptr, a),
+               std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atolinf, 1e6,
-				       nullptr, a),
-	       std::domain_error);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atolinf,
+                                       1e6, nullptr, a),
+               std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atolNaN, 1e6,
-				       nullptr, a),
-	       std::domain_error);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atolNaN,
+                                       1e6, nullptr, a),
+               std::domain_error);
 }
 
 TEST(ode_bdf_prim, max_num_steps_errors) {
@@ -330,16 +330,16 @@ TEST(ode_bdf_prim, max_num_steps_errors) {
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6, max_num_steps,
-					  nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                          max_num_steps, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6, max_num_steps_negative,
-				       nullptr, a),
-	       std::domain_error);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                       max_num_steps_negative, nullptr, a),
+               std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6, max_num_steps_zero,
-				       nullptr, a),
-	       std::domain_error);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                       max_num_steps_zero, nullptr, a),
+               std::domain_error);
 }
 
 TEST(ode_bdf_prim, rhs_wrong_size_errors) {
@@ -349,10 +349,10 @@ TEST(ode_bdf_prim, rhs_wrong_size_errors) {
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6, 100,
-					  nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                          100, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArgWrongSize(), y0, t0, ts, 1e-6, 1e-6, 100,
-				       nullptr, a),
-	       std::invalid_argument);
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArgWrongSize(), y0, t0, ts, 1e-6,
+                                       1e-6, 100, nullptr, a),
+               std::invalid_argument);
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index dc9e6a757f6..4d1df9680c4 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -534,41 +534,41 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_error_test) {
                     exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
-  double yT1 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                       nullptr, ad)[0](0);
+  double yT1 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                             1e6, nullptr, ad)[0](0);
   check_yT(yT1);
 
-  var yT2 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+  var yT2 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                          1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
-  var yT3 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+  var yT3 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
-  var yT4 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+  var yT4 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
   check_ts(ts);
   check_a(a);
 
-  var yT5 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+  var yT5 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
+                                          1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
-  var yT6 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+  var yT6 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
+                                          1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
@@ -576,7 +576,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_error_test) {
   check_a(a);
 
   var yT7 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+                                          nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
@@ -584,7 +584,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_error_test) {
   check_ts(ts);
 
   var yT8 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+                                          nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -592,31 +592,31 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_error_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT9 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+  var yT9 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
+                                          1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
-  var yT10 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+  var yT10 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
+                                           1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
   check_y0(y0);
   check_a(a);
 
-  var yT11 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+  var yT11 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
   check_y0(y0);
   check_ts(ts);
 
-  var yT12 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+  var yT12 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -624,16 +624,16 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_error_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT13 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+  var yT13 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
+                                           1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
   check_y0(y0);
   check_t0(t0);
 
-  var yT14 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+  var yT14 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
+                                           1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -642,7 +642,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_error_test) {
   check_a(a);
 
   var yT15 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                           nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -651,7 +651,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_error_test) {
   check_ts(ts);
 
   var yT16 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                           nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
@@ -701,57 +701,59 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_sens_error_test) {
                     exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
-  double yT1 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {}, 1e6,
-                                       nullptr, ad)[0](0);
+  double yT1 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {}, 1e6, nullptr, ad)[0](0);
   check_yT(yT1);
 
-  var yT2 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
-                                    nullptr, a)[0](0);
+  var yT2 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
-  var yT3 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {}, 1e6,
-                                    nullptr, ad)[0](0);
+  var yT3 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {}, 1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
-  var yT4 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
-                                    nullptr, a)[0](0);
+  var yT4 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
   check_ts(ts);
   check_a(a);
 
-  var yT5 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
-                                    nullptr, ad)[0](0);
+  var yT5 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
-  var yT6 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
-                                    nullptr, a)[0](0);
+  var yT6 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10,
+                                               1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
+                                               nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
   check_t0(t0);
   check_a(a);
 
-  var yT7 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
-                                    nullptr, ad)[0](0);
+  var yT7 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
   check_t0(t0);
   check_ts(ts);
 
-  var yT8 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
-                                    nullptr, a)[0](0);
+  var yT8 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0, ts, 1e-10, 1e-10,
+                                               1e-6, {1e-6, 1e-6}, 1e6, nullptr,
+                                               a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -759,31 +761,33 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_sens_error_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT9 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
-                                    nullptr, ad)[0](0);
+  var yT9 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
-  var yT10 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
-                                     nullptr, a)[0](0);
+  var yT10 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10,
+                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
+                                                nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
   check_y0(y0);
   check_a(a);
 
-  var yT11 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
-                                     nullptr, ad)[0](0);
+  var yT11 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
   check_y0(y0);
   check_ts(ts);
 
-  var yT12 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
-                                     nullptr, a)[0](0);
+  var yT12 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0d, ts, 1e-10,
+                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
+                                                nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -791,16 +795,17 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_sens_error_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT13 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
-                                     nullptr, ad)[0](0);
+  var yT13 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
   check_y0(y0);
   check_t0(t0);
 
-  var yT14 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
-                                     nullptr, a)[0](0);
+  var yT14 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0, tsd, 1e-10,
+                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
+                                                nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -808,8 +813,8 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_sens_error_test) {
   check_t0(t0);
   check_a(a);
 
-  var yT15 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e-6, { 1e-6 }, 1e6,
-                                     nullptr, ad)[0](0);
+  var yT15 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0, t0, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -817,8 +822,9 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_sens_error_test) {
   check_t0(t0);
   check_ts(ts);
 
-  var yT16 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
-                                     nullptr, a)[0](0);
+  var yT16 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0, ts, 1e-10, 1e-10,
+                                                1e-6, {1e-6, 1e-6}, 1e6,
+                                                nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
@@ -827,15 +833,18 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_sens_error_test) {
   check_ts(ts);
   check_a(a);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, { 1e-6, 1e-6 }, 1e6,
-						  nullptr, a),
-						  std::invalid_argument);
+  EXPECT_THROW(
+      stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                         1e-6, {1e-6, 1e-6}, 1e6, nullptr, a),
+      std::invalid_argument);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, -1e-6, { 1e-6 }, 1e6,
-						  nullptr, a),
-						  std::domain_error);
+  EXPECT_THROW(
+      stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                         -1e-6, {1e-6}, 1e6, nullptr, a),
+      std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, -1e-6, { -1e-6 }, 1e6,
-						  nullptr, a),
-						  std::domain_error);
+  EXPECT_THROW(
+      stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                         -1e-6, {-1e-6}, 1e6, nullptr, a),
+      std::domain_error);
 }

From 6ae558cb0ea7c90d768c812810e0e65508671f06 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 1 Jun 2020 15:47:11 -0400
Subject: [PATCH 132/189] Hopefully completed adding tests to new ode
 functions.

Changed ode_rk45 error behavior to match cvodes_integrator-based ODEs (design-doc #19)
---
 stan/math/prim/functor/ode_rk45.hpp           |  17 +-
 .../functor/integrate_ode_rk45_prim_test.cpp  |   6 +-
 .../math/prim/functor/ode_rk45_prim_test.cpp  | 261 ++++++
 .../prim/functor/ode_rk45_tol_prim_test.cpp   | 351 ++++++++
 .../math/rev/functor/ode_adams_prim_test.cpp  | 261 ++++++
 .../math/rev/functor/ode_adams_rev_test.cpp   | 553 ++----------
 .../rev/functor/ode_adams_tol_prim_test.cpp   | 351 ++++++++
 .../rev/functor/ode_adams_tol_rev_test.cpp    | 845 ++++++++++++++++++
 .../math/rev/functor/ode_bdf_prim_test.cpp    | 187 +---
 .../math/rev/functor/ode_bdf_rev_test.cpp     | 442 +--------
 .../rev/functor/ode_bdf_tol_prim_test.cpp     | 351 ++++++++
 .../math/rev/functor/ode_bdf_tol_rev_test.cpp | 845 ++++++++++++++++++
 .../math/rev/functor/ode_rk45_rev_test.cpp    | 184 ++--
 .../rev/functor/ode_rk45_tol_rev_test.cpp     | 490 ++++++++++
 14 files changed, 4047 insertions(+), 1097 deletions(-)
 create mode 100644 test/unit/math/prim/functor/ode_rk45_prim_test.cpp
 create mode 100644 test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
 create mode 100644 test/unit/math/rev/functor/ode_adams_prim_test.cpp
 create mode 100644 test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
 create mode 100644 test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
 create mode 100644 test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
 create mode 100644 test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
 create mode 100644 test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp

diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index 3ce7a856684..e8f53f74394 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -65,7 +65,7 @@ ode_rk45_tol(const F& f,
   using boost::numeric::odeint::vector_space_algebra;
 
   using T_initial_or_t0 = return_type_t<T_initial, T_t0>;
-
+  
   Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1> y0 = y0_arg.unaryExpr(
       [](const T_initial& val) { return T_initial_or_t0(val); });
 
@@ -83,18 +83,9 @@ ode_rk45_tol(const F& f,
   check_sorted("integrate_ode_rk45", "times", ts);
   check_less("integrate_ode_rk45", "initial time", t0, ts[0]);
 
-  if (relative_tolerance <= 0) {
-    invalid_argument("integrate_ode_rk45", "relative_tolerance,",
-                     relative_tolerance, "", ", must be greater than 0");
-  }
-  if (absolute_tolerance <= 0) {
-    invalid_argument("integrate_ode_rk45", "absolute_tolerance,",
-                     absolute_tolerance, "", ", must be greater than 0");
-  }
-  if (max_num_steps <= 0) {
-    invalid_argument("integrate_ode_rk45", "max_num_steps,", max_num_steps, "",
-                     ", must be greater than 0");
-  }
+  check_positive_finite("integrate_ode_rk45", "relative_tolerance", relative_tolerance);
+  check_positive_finite("integrate_ode_rk45", "absolute_tolerance", absolute_tolerance);
+  check_positive("integrate_ode_rk45", "max_num_steps", max_num_steps);
 
   using return_t = return_type_t<T_initial, T_t0, T_ts, Args...>;
   // creates basic or coupled system by template specializations
diff --git a/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp b/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
index d7a5a50dc0a..f04b083fff5 100644
--- a/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
+++ b/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
@@ -140,15 +140,15 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions) {
 
   EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int, 0,
                                        -1, 1e-6, 10)),
-                   std::invalid_argument, "relative_tolerance");
+                   std::domain_error, "relative_tolerance");
 
   EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int, 0,
                                        1e-6, -1, 10)),
-                   std::invalid_argument, "absolute_tolerance");
+                   std::domain_error, "absolute_tolerance");
 
   EXPECT_THROW_MSG((integrate_ode_rk45(harm_osc, y0, t0, ts, theta, x, x_int, 0,
                                        1e-6, 1e-6, -1)),
-                   std::invalid_argument, "max_num_steps");
+                   std::domain_error, "max_num_steps");
 }
 
 TEST(StanMathOde_integrate_ode_rk45, error_conditions_nan) {
diff --git a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
new file mode 100644
index 00000000000..43c8ea822be
--- /dev/null
+++ b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
@@ -0,0 +1,261 @@
+#include <stan/math/rev.hpp>
+#include <gtest/gtest.h>
+#include <iostream>
+#include <vector>
+
+template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
+T sum_(T arg) {
+  return arg;
+}
+
+template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
+auto sum_(EigMat&& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
+auto sum_(Vec&& arg) {
+  stan::scalar_type_t<Vec> sum = 0;
+  for (size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
+  }
+  return sum;
+}
+
+struct CosArg1 {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos(sum_(vec) * t);
+    return out;
+  }
+};
+
+struct Cos2Arg {
+  template <typename T0, typename T1, typename T2, typename T3>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a, const T3& b) const {
+    Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos((sum_(a) + sum_(b)) * t);
+    return out;
+  }
+};
+
+struct CosArgWrongSize {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(2);
+    out << stan::math::cos(sum_(vec) * t), 0;
+    return out;
+  }
+};
+
+TEST(ode_rk45_prim, y0_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  Eigen::VectorXd y0inf(1);
+  Eigen::VectorXd y0NaN(1);
+  Eigen::VectorXd y0_empty;
+  y0NaN << stan::math::NOT_A_NUMBER;
+  y0inf << stan::math::INFTY;
+  int t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0inf, t0, ts, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0NaN, t0, ts, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0_empty, t0, ts, nullptr, a),
+               std::invalid_argument);
+}
+
+TEST(ode_rk45_prim, t0_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  double t0inf = stan::math::INFTY;
+  double t0NaN = stan::math::NOT_A_NUMBER;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0inf, ts, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0NaN, ts, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_rk45_prim, ts_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+  std::vector<double> ts_repeat = {0.45, 0.45};
+  std::vector<double> ts_empty = {};
+  std::vector<double> ts_early = {-0.45, 0.2};
+  std::vector<double> ts_decreasing = {0.45, 0.2};
+  std::vector<double> tsinf = {stan::math::INFTY, 1.1};
+  std::vector<double> tsNaN = {0.45, stan::math::NOT_A_NUMBER};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a));
+
+  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts_repeat, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts_empty,
+				   nullptr, a),
+               std::invalid_argument);
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts_early,
+				   nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts_decreasing,
+				   nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, tsinf,
+				   nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, tsNaN,
+				   nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_rk45_prim, one_arg_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+  double ainf = stan::math::INFTY;
+  double aNaN = stan::math::NOT_A_NUMBER;
+
+  std::vector<double> va = {a};
+  std::vector<double> vainf = {ainf};
+  std::vector<double> vaNaN = {aNaN};
+
+  Eigen::VectorXd ea(1);
+  ea << a;
+  Eigen::VectorXd eainf(1);
+  eainf << ainf;
+  Eigen::VectorXd eaNaN(1);
+  eaNaN << aNaN;
+
+  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+				      nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                       nullptr, ainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                       nullptr, aNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+				      nullptr, va));
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                       nullptr, vainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                       nullptr, vaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+				      nullptr, ea));
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                       nullptr, eainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                       nullptr, eaNaN),
+               std::domain_error);
+}
+
+TEST(ode_rk45_prim, two_arg_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+  double ainf = stan::math::INFTY;
+  double aNaN = stan::math::NOT_A_NUMBER;
+
+  std::vector<double> va = {a};
+  std::vector<double> vainf = {ainf};
+  std::vector<double> vaNaN = {aNaN};
+
+  Eigen::VectorXd ea(1);
+  ea << a;
+  Eigen::VectorXd eainf(1);
+  eainf << ainf;
+  Eigen::VectorXd eaNaN(1);
+  eaNaN << aNaN;
+
+  EXPECT_NO_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
+				      nullptr, a, a));
+
+  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
+                                       nullptr, a, ainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
+                                       nullptr, a, aNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
+				      nullptr, a, va));
+
+  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
+                                       nullptr, a, vainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
+                                       nullptr, a, vaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
+				      nullptr, a, ea));
+
+  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
+                                       nullptr, a, eainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
+                                       nullptr, a, eaNaN),
+               std::domain_error);
+}
+
+TEST(ode_rk45_prim, rhs_wrong_size_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArgWrongSize(), y0, t0, ts, nullptr, a),
+               std::invalid_argument);
+}
diff --git a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
new file mode 100644
index 00000000000..09b63d497d3
--- /dev/null
+++ b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
@@ -0,0 +1,351 @@
+#include <stan/math/prim.hpp>
+#include <gtest/gtest.h>
+#include <iostream>
+#include <vector>
+
+template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
+T sum_(T arg) {
+  return arg;
+}
+
+template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
+auto sum_(EigMat&& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
+auto sum_(Vec&& arg) {
+  stan::scalar_type_t<Vec> sum = 0;
+  for (size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
+  }
+  return sum;
+}
+
+struct CosArg1 {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos(sum_(vec) * t);
+    return out;
+  }
+};
+
+struct Cos2Arg {
+  template <typename T0, typename T1, typename T2, typename T3>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a, const T3& b) const {
+    Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos((sum_(a) + sum_(b)) * t);
+    return out;
+  }
+};
+
+struct CosArgWrongSize {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(2);
+    out << stan::math::cos(sum_(vec) * t), 0;
+    return out;
+  }
+};
+
+TEST(ode_rk45_tol_prim, y0_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  Eigen::VectorXd y0inf(1);
+  Eigen::VectorXd y0NaN(1);
+  Eigen::VectorXd y0_empty;
+  y0NaN << stan::math::NOT_A_NUMBER;
+  y0inf << stan::math::INFTY;
+  int t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0inf, t0, ts, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0NaN, t0, ts, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0_empty, t0, ts, 1e-10,
+                                       1e-10, 1e6, nullptr, a),
+               std::invalid_argument);
+}
+
+TEST(ode_rk45_tol_prim, t0_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  double t0inf = stan::math::INFTY;
+  double t0NaN = stan::math::NOT_A_NUMBER;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0inf, ts, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0NaN, ts, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_rk45_tol_prim, ts_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+  std::vector<double> ts_repeat = {0.45, 0.45};
+  std::vector<double> ts_empty = {};
+  std::vector<double> ts_early = {-0.45, 0.2};
+  std::vector<double> ts_decreasing = {0.45, 0.2};
+  std::vector<double> tsinf = {stan::math::INFTY, 1.1};
+  std::vector<double> tsNaN = {0.45, stan::math::NOT_A_NUMBER};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a));
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
+                                          1e-10, 1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
+                                       1e-10, 1e6, nullptr, a),
+               std::invalid_argument);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_early, 1e-10,
+                                       1e-10, 1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_decreasing, 1e-10,
+                                       1e-10, 1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, tsinf, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, tsNaN, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_rk45_tol_prim, one_arg_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+  double ainf = stan::math::INFTY;
+  double aNaN = stan::math::NOT_A_NUMBER;
+
+  std::vector<double> va = {a};
+  std::vector<double> vainf = {ainf};
+  std::vector<double> vaNaN = {aNaN};
+
+  Eigen::VectorXd ea(1);
+  ea << a;
+  Eigen::VectorXd eainf(1);
+  eainf << ainf;
+  Eigen::VectorXd eaNaN(1);
+  eaNaN << aNaN;
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, ainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, aNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, va));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, vainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, vaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, ea));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, eainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, eaNaN),
+               std::domain_error);
+}
+
+TEST(ode_rk45_tol_prim, two_arg_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+  double ainf = stan::math::INFTY;
+  double aNaN = stan::math::NOT_A_NUMBER;
+
+  std::vector<double> va = {a};
+  std::vector<double> vainf = {ainf};
+  std::vector<double> vaNaN = {aNaN};
+
+  Eigen::VectorXd ea(1);
+  ea << a;
+  Eigen::VectorXd eainf(1);
+  eainf << ainf;
+  Eigen::VectorXd eaNaN(1);
+  eaNaN << aNaN;
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a, a));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, ainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, aNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a, va));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, vainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, vaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a, ea));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, eainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, eaNaN),
+               std::domain_error);
+}
+
+TEST(ode_rk45_tol_prim, rtol_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double rtol = 1e-6;
+  double rtol_negative = -1e-6;
+  double rtolinf = stan::math::INFTY;
+  double rtolNaN = stan::math::NOT_A_NUMBER;
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, rtol, 1e-10,
+                                          1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, rtol_negative,
+                                       1e-10, 1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, rtolinf, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, rtolNaN, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_rk45_tol_prim, atol_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double atol = 1e-6;
+  double atol_negative = -1e-6;
+  double atolinf = stan::math::INFTY;
+  double atolNaN = stan::math::NOT_A_NUMBER;
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, atol,
+                                          1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6,
+                                       atol_negative, 1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, atolinf,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, atolNaN,
+                                       1e6, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_rk45_tol_prim, max_num_steps_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  int max_num_steps = 500;
+  int max_num_steps_negative = -500;
+  int max_num_steps_zero = 0;
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                          max_num_steps, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                       max_num_steps_negative, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                       max_num_steps_zero, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_rk45_tol_prim, rhs_wrong_size_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                          100, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArgWrongSize(), y0, t0, ts, 1e-6,
+                                       1e-6, 100, nullptr, a),
+               std::invalid_argument);
+}
diff --git a/test/unit/math/rev/functor/ode_adams_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
new file mode 100644
index 00000000000..52b664f5a2b
--- /dev/null
+++ b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
@@ -0,0 +1,261 @@
+#include <stan/math/rev.hpp>
+#include <gtest/gtest.h>
+#include <iostream>
+#include <vector>
+
+template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
+T sum_(T arg) {
+  return arg;
+}
+
+template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
+auto sum_(EigMat&& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
+auto sum_(Vec&& arg) {
+  stan::scalar_type_t<Vec> sum = 0;
+  for (size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
+  }
+  return sum;
+}
+
+struct CosArg1 {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos(sum_(vec) * t);
+    return out;
+  }
+};
+
+struct Cos2Arg {
+  template <typename T0, typename T1, typename T2, typename T3>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a, const T3& b) const {
+    Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos((sum_(a) + sum_(b)) * t);
+    return out;
+  }
+};
+
+struct CosArgWrongSize {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(2);
+    out << stan::math::cos(sum_(vec) * t), 0;
+    return out;
+  }
+};
+
+TEST(ode_adams_prim, y0_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  Eigen::VectorXd y0inf(1);
+  Eigen::VectorXd y0NaN(1);
+  Eigen::VectorXd y0_empty;
+  y0NaN << stan::math::NOT_A_NUMBER;
+  y0inf << stan::math::INFTY;
+  int t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0inf, t0, ts, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0NaN, t0, ts, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0_empty, t0, ts, nullptr, a),
+               std::invalid_argument);
+}
+
+TEST(ode_adams_prim, t0_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  double t0inf = stan::math::INFTY;
+  double t0NaN = stan::math::NOT_A_NUMBER;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0inf, ts, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0NaN, ts, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_adams_prim, ts_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+  std::vector<double> ts_repeat = {0.45, 0.45};
+  std::vector<double> ts_empty = {};
+  std::vector<double> ts_early = {-0.45, 0.2};
+  std::vector<double> ts_decreasing = {0.45, 0.2};
+  std::vector<double> tsinf = {stan::math::INFTY, 1.1};
+  std::vector<double> tsNaN = {0.45, stan::math::NOT_A_NUMBER};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a));
+
+  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts_repeat, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts_empty,
+				   nullptr, a),
+               std::invalid_argument);
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts_early,
+				   nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts_decreasing,
+				   nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, tsinf,
+				   nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, tsNaN,
+				   nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_adams_prim, one_arg_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+  double ainf = stan::math::INFTY;
+  double aNaN = stan::math::NOT_A_NUMBER;
+
+  std::vector<double> va = {a};
+  std::vector<double> vainf = {ainf};
+  std::vector<double> vaNaN = {aNaN};
+
+  Eigen::VectorXd ea(1);
+  ea << a;
+  Eigen::VectorXd eainf(1);
+  eainf << ainf;
+  Eigen::VectorXd eaNaN(1);
+  eaNaN << aNaN;
+
+  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
+				      nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                       nullptr, ainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                       nullptr, aNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
+				      nullptr, va));
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                       nullptr, vainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                       nullptr, vaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
+				      nullptr, ea));
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                       nullptr, eainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                       nullptr, eaNaN),
+               std::domain_error);
+}
+
+TEST(ode_adams_prim, two_arg_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+  double ainf = stan::math::INFTY;
+  double aNaN = stan::math::NOT_A_NUMBER;
+
+  std::vector<double> va = {a};
+  std::vector<double> vainf = {ainf};
+  std::vector<double> vaNaN = {aNaN};
+
+  Eigen::VectorXd ea(1);
+  ea << a;
+  Eigen::VectorXd eainf(1);
+  eainf << ainf;
+  Eigen::VectorXd eaNaN(1);
+  eaNaN << aNaN;
+
+  EXPECT_NO_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
+				      nullptr, a, a));
+
+  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
+                                       nullptr, a, ainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
+                                       nullptr, a, aNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
+				      nullptr, a, va));
+
+  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
+                                       nullptr, a, vainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
+                                       nullptr, a, vaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
+				      nullptr, a, ea));
+
+  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
+                                       nullptr, a, eainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
+                                       nullptr, a, eaNaN),
+               std::domain_error);
+}
+
+TEST(ode_adams_prim, rhs_wrong_size_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_adams(CosArgWrongSize(), y0, t0, ts, nullptr, a),
+               std::invalid_argument);
+}
diff --git a/test/unit/math/rev/functor/ode_adams_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
index 04dc320f886..0893187c55a 100644
--- a/test/unit/math/rev/functor/ode_adams_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
@@ -1,12 +1,7 @@
 #include <stan/math/rev.hpp>
-#include <boost/numeric/odeint.hpp>
 #include <gtest/gtest.h>
-#include <test/unit/util.hpp>
 #include <iostream>
-#include <sstream>
 #include <vector>
-#include <limits>
-#include <string>
 
 using stan::math::var;
 
@@ -53,7 +48,7 @@ struct Cos2Arg {
   }
 };
 
-TEST(StanMathOde_ode_adams_tol, int_t0) {
+TEST(StanMathOde_ode_adams, int_t0) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -63,14 +58,14 @@ TEST(StanMathOde_ode_adams_tol, int_t0) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
-      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                  nullptr, a);
+      = stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
   EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
 }
 
-TEST(StanMathOde_ode_adams_tol, int_ts) {
+TEST(StanMathOde_ode_adams, int_ts) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -80,91 +75,77 @@ TEST(StanMathOde_ode_adams_tol, int_ts) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
-      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                  nullptr, a);
+      = stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
   EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
 }
 
-TEST(StanMathOde_ode_adams_tol, ts_repeat) {
+TEST(StanMathOde_ode_adams, t0) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
-  double t0 = 0.0;
-  std::vector<var> ts = {0.45, 0.45, 1.1, 1.1};
+  var t0 = 0.0;
+  std::vector<double> ts = {0.45, 1.1};
 
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                  nullptr, a);
+      = stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                nullptr, a);
 
   output[0][0].grad();
 
   EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
 
   stan::math::set_zero_all_adjoints();
 
   output[1][0].grad();
 
-  EXPECT_FLOAT_EQ(output[1][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(ts[1].adj(), 0.78070695113);
-
-  stan::math::set_zero_all_adjoints();
-
-  output[2][0].grad();
-
-  EXPECT_FLOAT_EQ(output[2][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(ts[2].adj(), -0.0791208888);
-
-  stan::math::set_zero_all_adjoints();
-
-  output[3][0].grad();
-
-  EXPECT_FLOAT_EQ(output[3][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(ts[3].adj(), -0.0791208888);
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
 }
 
-TEST(StanMathOde_ode_adams_tol, t0) {
+TEST(StanMathOde_ode_adams, ts) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
-  var t0 = 0.0;
-  std::vector<double> ts = {0.45, 1.1};
+  double t0 = 0.0;
+  std::vector<var> ts = {0.45, 1.1};
 
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                  nullptr, a);
+      = stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                nullptr, a);
 
   output[0][0].grad();
 
   EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
 
   stan::math::set_zero_all_adjoints();
 
   output[1][0].grad();
 
   EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+  EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
 }
 
-TEST(StanMathOde_ode_adams_tol, ts) {
+TEST(StanMathOde_ode_adams, ts_repeat) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0.0;
-  std::vector<var> ts = {0.45, 1.1};
+  std::vector<var> ts = {0.45, 0.45, 1.1, 1.1};
 
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                  nullptr, a);
+      = stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                nullptr, a);
 
   output[0][0].grad();
 
@@ -175,11 +156,25 @@ TEST(StanMathOde_ode_adams_tol, ts) {
 
   output[1][0].grad();
 
-  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[1].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[2][0].grad();
+
+  EXPECT_FLOAT_EQ(output[2][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[2].adj(), -0.0791208888);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[3][0].grad();
+
+  EXPECT_FLOAT_EQ(output[3][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[3].adj(), -0.0791208888);
 }
 
-TEST(StanMathOde_ode_adams_tol, scalar_arg) {
+TEST(StanMathOde_ode_adams, scalar_arg) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -188,8 +183,8 @@ TEST(StanMathOde_ode_adams_tol, scalar_arg) {
 
   var a = 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
-                                         1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -197,7 +192,7 @@ TEST(StanMathOde_ode_adams_tol, scalar_arg) {
   EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_adams_tol, scalar_arg_multi_time) {
+TEST(StanMathOde_ode_adams, scalar_arg_multi_time) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -207,8 +202,8 @@ TEST(StanMathOde_ode_adams_tol, scalar_arg_multi_time) {
   var a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                  nullptr, a);
+      = stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                nullptr, a);
 
   output[0](0).grad();
 
@@ -223,7 +218,7 @@ TEST(StanMathOde_ode_adams_tol, scalar_arg_multi_time) {
   EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_adams_tol, std_vector_arg) {
+TEST(StanMathOde_ode_adams, std_vector_arg) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -232,8 +227,8 @@ TEST(StanMathOde_ode_adams_tol, std_vector_arg) {
 
   std::vector<var> a = {1.5};
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
-                                         1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -241,7 +236,7 @@ TEST(StanMathOde_ode_adams_tol, std_vector_arg) {
   EXPECT_FLOAT_EQ(a[0].adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_adams_tol, vector_arg) {
+TEST(StanMathOde_ode_adams, vector_arg) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -251,8 +246,8 @@ TEST(StanMathOde_ode_adams_tol, vector_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
-                                         1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -260,7 +255,7 @@ TEST(StanMathOde_ode_adams_tol, vector_arg) {
   EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_adams_tol, row_vector_arg) {
+TEST(StanMathOde_ode_adams, row_vector_arg) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -270,8 +265,8 @@ TEST(StanMathOde_ode_adams_tol, row_vector_arg) {
   Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
-                                         1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -279,7 +274,7 @@ TEST(StanMathOde_ode_adams_tol, row_vector_arg) {
   EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_adams_tol, matrix_arg) {
+TEST(StanMathOde_ode_adams, matrix_arg) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -289,8 +284,8 @@ TEST(StanMathOde_ode_adams_tol, matrix_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
   a << 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
-                                         1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts,
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -298,22 +293,23 @@ TEST(StanMathOde_ode_adams_tol, matrix_arg) {
   EXPECT_FLOAT_EQ(a(0, 0).adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_adams_tol, scalar_std_vector_args) {
+TEST(StanMathOde_ode_adams, scalar_std_vector_args) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0.0;
   std::vector<double> ts = {1.1};
 
-  var a0 = 0.0;
-  std::vector<var> a1 = {1.5};
+  var a0 = 0.75;
+  std::vector<var> a1 = {0.75};
 
-  var output = stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10,
-                                         1e6, nullptr, a0, a1)[0][0];
+  var output = stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
+                                       nullptr, a0, a1)[0][0];
 
   output.grad();
 
   EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a0.adj(), -0.50107310888);
   EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
 }
 
@@ -326,7 +322,7 @@ struct ayt {
   }
 };
 
-TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
+TEST(StanMathOde_ode_adams, arg_combos_test) {
   var t0 = 0.5;
   var a = 0.2;
   std::vector<var> ts = {1.25};
@@ -366,393 +362,57 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
                     exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
-  double yT1 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                         1e6, nullptr, ad)[0](0);
-  check_yT(yT1);
-
-  var yT2 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT2.grad();
-  check_yT(yT2);
-  check_a(a);
-
-  var yT3 = stan::math::ode_adams_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT3.grad();
-  check_yT(yT3);
-  check_ts(ts);
-
-  var yT4 = stan::math::ode_adams_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT4.grad();
-  check_yT(yT4);
-  check_ts(ts);
-  check_a(a);
-
-  var yT5 = stan::math::ode_adams_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT5.grad();
-  check_yT(yT5);
-  check_t0(t0);
-
-  var yT6 = stan::math::ode_adams_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT6.grad();
-  check_yT(yT6);
-  check_t0(t0);
-  check_a(a);
-
-  var yT7 = stan::math::ode_adams_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT7.grad();
-  check_yT(yT7);
-  check_t0(t0);
-  check_ts(ts);
-
-  var yT8 = stan::math::ode_adams_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT8.grad();
-  check_yT(yT8);
-  check_t0(t0);
-  check_ts(ts);
-  check_a(a);
-
-  var yT9 = stan::math::ode_adams_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT9.grad();
-  check_yT(yT9);
-  check_y0(y0);
-
-  var yT10 = stan::math::ode_adams_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                       nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT10.grad();
-  check_yT(yT10);
-  check_y0(y0);
-  check_a(a);
-
-  var yT11 = stan::math::ode_adams_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT11.grad();
-  check_yT(yT11);
-  check_y0(y0);
-  check_ts(ts);
-
-  var yT12 = stan::math::ode_adams_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT12.grad();
-  check_yT(yT12);
-  check_y0(y0);
-  check_ts(ts);
-  check_a(a);
-
-  var yT13 = stan::math::ode_adams_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+  double yT1 = stan::math::ode_adams(ayt(), y0d, t0d, tsd,
                                        nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT13.grad();
-  check_yT(yT13);
-  check_y0(y0);
-  check_t0(t0);
-
-  var yT14 = stan::math::ode_adams_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                       nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT14.grad();
-  check_yT(yT14);
-  check_y0(y0);
-  check_t0(t0);
-  check_a(a);
-
-  var yT15 = stan::math::ode_adams_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT15.grad();
-  check_yT(yT15);
-  check_y0(y0);
-  check_t0(t0);
-  check_ts(ts);
-
-  var yT16 = stan::math::ode_adams_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT16.grad();
-  check_yT(yT16);
-  check_y0(y0);
-  check_t0(t0);
-  check_ts(ts);
-  check_a(a);
-}
-
-TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
-  var t0 = 0.5;
-  var a = 0.2;
-  std::vector<var> ts = {1.25};
-  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
-  y0 << 0.75;
-
-  double t0d = stan::math::value_of(t0);
-  double ad = stan::math::value_of(a);
-  std::vector<double> tsd = stan::math::value_of(ts);
-  Eigen::VectorXd y0d = stan::math::value_of(y0);
-
-  auto check_yT = [&](auto yT) {
-    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
-                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_t0 = [&](var t0) {
-    EXPECT_FLOAT_EQ(
-        t0.adj(),
-        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_a = [&](var a) {
-    EXPECT_FLOAT_EQ(a.adj(),
-                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
-                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_ts = [&](std::vector<var> ts) {
-    EXPECT_FLOAT_EQ(
-        ts[0].adj(),
-        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
-    EXPECT_FLOAT_EQ(y0(0).adj(),
-                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  double yT1 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, tsd, 1e-10,
-                                               1e-10, 1e6, nullptr, ad)[0](0);
-  check_yT(yT1);
-
-  var yT2 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                            1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT2.grad();
-  check_yT(yT2);
-  check_a(a);
-
-  var yT3 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT3.grad();
-  check_yT(yT3);
-  check_ts(ts);
-
-  var yT4 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT4.grad();
-  check_yT(yT4);
-  check_ts(ts);
-  check_a(a);
-
-  var yT5 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
-                                            1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT5.grad();
-  check_yT(yT5);
-  check_t0(t0);
-
-  var yT6 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
-                                            1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT6.grad();
-  check_yT(yT6);
-  check_t0(t0);
-  check_a(a);
-
-  var yT7 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT7.grad();
-  check_yT(yT7);
-  check_t0(t0);
-  check_ts(ts);
-
-  var yT8 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT8.grad();
-  check_yT(yT8);
-  check_t0(t0);
-  check_ts(ts);
-  check_a(a);
-
-  var yT9 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
-                                            1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT9.grad();
-  check_yT(yT9);
-  check_y0(y0);
-
-  var yT10 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
-                                             1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT10.grad();
-  check_yT(yT10);
-  check_y0(y0);
-  check_a(a);
-
-  var yT11 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
-                                             1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT11.grad();
-  check_yT(yT11);
-  check_y0(y0);
-  check_ts(ts);
-
-  var yT12 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
-                                             1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT12.grad();
-  check_yT(yT12);
-  check_y0(y0);
-  check_ts(ts);
-  check_a(a);
-
-  var yT13 = stan::math::ode_adams_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
-                                             1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT13.grad();
-  check_yT(yT13);
-  check_y0(y0);
-  check_t0(t0);
-
-  var yT14 = stan::math::ode_adams_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
-                                             1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT14.grad();
-  check_yT(yT14);
-  check_y0(y0);
-  check_t0(t0);
-  check_a(a);
-
-  var yT15 = stan::math::ode_adams_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10,
-                                             1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT15.grad();
-  check_yT(yT15);
-  check_y0(y0);
-  check_t0(t0);
-  check_ts(ts);
-
-  var yT16 = stan::math::ode_adams_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10,
-                                             1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT16.grad();
-  check_yT(yT16);
-  check_y0(y0);
-  check_t0(t0);
-  check_ts(ts);
-  check_a(a);
-}
-
-TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
-  var t0 = 0.5;
-  var a = 0.2;
-  std::vector<var> ts = {1.25};
-  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
-  y0 << 0.75;
-
-  double t0d = stan::math::value_of(t0);
-  double ad = stan::math::value_of(a);
-  std::vector<double> tsd = stan::math::value_of(ts);
-  Eigen::VectorXd y0d = stan::math::value_of(y0);
-
-  auto check_yT = [&](auto yT) {
-    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
-                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_t0 = [&](var t0) {
-    EXPECT_FLOAT_EQ(
-        t0.adj(),
-        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_a = [&](var a) {
-    EXPECT_FLOAT_EQ(a.adj(),
-                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
-                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_ts = [&](std::vector<var> ts) {
-    EXPECT_FLOAT_EQ(
-        ts[0].adj(),
-        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
-    EXPECT_FLOAT_EQ(y0(0).adj(),
-                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  double yT1 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {}, 1e6, nullptr, ad)[0](0);
   check_yT(yT1);
 
-  var yT2 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, a)[0](0);
+  var yT2 = stan::math::ode_adams(ayt(), y0d, t0d, tsd,
+                                    nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
-  var yT3 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {}, 1e6, nullptr, ad)[0](0);
+  var yT3 = stan::math::ode_adams(ayt(), y0d, t0d, ts,
+                                    nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
-  var yT4 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, a)[0](0);
+  var yT4 = stan::math::ode_adams(ayt(), y0d, t0d, ts,
+                                    nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
   check_ts(ts);
   check_a(a);
 
-  var yT5 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT5 = stan::math::ode_adams(ayt(), y0d, t0, tsd,
+                                    nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
-  var yT6 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10,
-                                                 1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
-                                                 nullptr, a)[0](0);
+  var yT6 = stan::math::ode_adams(ayt(), y0d, t0, tsd,
+                                    nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
   check_t0(t0);
   check_a(a);
 
-  var yT7 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT7 = stan::math::ode_adams(ayt(), y0d, t0, ts,
+                                    nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
   check_t0(t0);
   check_ts(ts);
 
-  var yT8 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, ts, 1e-10,
-                                                 1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
-                                                 nullptr, a)[0](0);
+  var yT8 = stan::math::ode_adams(ayt(), y0d, t0, ts,
+                                    nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -760,33 +420,31 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT9 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT9 = stan::math::ode_adams(ayt(), y0, t0d, tsd,
+                                    nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
-  var yT10 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10,
-                                                  1e-10, 1e-6, {1e-6, 1e-6},
-                                                  1e6, nullptr, a)[0](0);
+  var yT10 = stan::math::ode_adams(ayt(), y0, t0d, tsd,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
   check_y0(y0);
   check_a(a);
 
-  var yT11 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT11 = stan::math::ode_adams(ayt(), y0, t0d, ts,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
   check_y0(y0);
   check_ts(ts);
 
-  var yT12 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, ts, 1e-10,
-                                                  1e-10, 1e-6, {1e-6, 1e-6},
-                                                  1e6, nullptr, a)[0](0);
+  var yT12 = stan::math::ode_adams(ayt(), y0, t0d, ts,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -794,17 +452,16 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT13 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT13 = stan::math::ode_adams(ayt(), y0, t0, tsd,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
   check_y0(y0);
   check_t0(t0);
 
-  var yT14 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, tsd, 1e-10,
-                                                  1e-10, 1e-6, {1e-6, 1e-6},
-                                                  1e6, nullptr, a)[0](0);
+  var yT14 = stan::math::ode_adams(ayt(), y0, t0, tsd,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -812,8 +469,8 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_t0(t0);
   check_a(a);
 
-  var yT15 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0, t0, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT15 = stan::math::ode_adams(ayt(), y0, t0, ts,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -821,9 +478,8 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_t0(t0);
   check_ts(ts);
 
-  var yT16 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, ts, 1e-10,
-                                                  1e-10, 1e-6, {1e-6, 1e-6},
-                                                  1e6, nullptr, a)[0](0);
+  var yT16 = stan::math::ode_adams(ayt(), y0, t0, ts,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
@@ -831,19 +487,4 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_t0(t0);
   check_ts(ts);
   check_a(a);
-
-  EXPECT_THROW(
-      stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                           1e-6, {1e-6, 1e-6}, 1e6, nullptr, a),
-      std::invalid_argument);
-
-  EXPECT_THROW(
-      stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                           -1e-6, {1e-6}, 1e6, nullptr, a),
-      std::domain_error);
-
-  EXPECT_THROW(
-      stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                           -1e-6, {-1e-6}, 1e6, nullptr, a),
-      std::domain_error);
 }
diff --git a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
new file mode 100644
index 00000000000..6a9188e016f
--- /dev/null
+++ b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
@@ -0,0 +1,351 @@
+#include <stan/math/rev.hpp>
+#include <gtest/gtest.h>
+#include <iostream>
+#include <vector>
+
+template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
+T sum_(T arg) {
+  return arg;
+}
+
+template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
+auto sum_(EigMat&& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
+auto sum_(Vec&& arg) {
+  stan::scalar_type_t<Vec> sum = 0;
+  for (size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
+  }
+  return sum;
+}
+
+struct CosArg1 {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos(sum_(vec) * t);
+    return out;
+  }
+};
+
+struct Cos2Arg {
+  template <typename T0, typename T1, typename T2, typename T3>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a, const T3& b) const {
+    Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos((sum_(a) + sum_(b)) * t);
+    return out;
+  }
+};
+
+struct CosArgWrongSize {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(2);
+    out << stan::math::cos(sum_(vec) * t), 0;
+    return out;
+  }
+};
+
+TEST(ode_adams_tol_prim, y0_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  Eigen::VectorXd y0inf(1);
+  Eigen::VectorXd y0NaN(1);
+  Eigen::VectorXd y0_empty;
+  y0NaN << stan::math::NOT_A_NUMBER;
+  y0inf << stan::math::INFTY;
+  int t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0inf, t0, ts, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0NaN, t0, ts, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0_empty, t0, ts, 1e-10,
+                                       1e-10, 1e6, nullptr, a),
+               std::invalid_argument);
+}
+
+TEST(ode_adams_tol_prim, t0_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  double t0inf = stan::math::INFTY;
+  double t0NaN = stan::math::NOT_A_NUMBER;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0inf, ts, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0NaN, ts, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_adams_tol_prim, ts_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+  std::vector<double> ts_repeat = {0.45, 0.45};
+  std::vector<double> ts_empty = {};
+  std::vector<double> ts_early = {-0.45, 0.2};
+  std::vector<double> ts_decreasing = {0.45, 0.2};
+  std::vector<double> tsinf = {stan::math::INFTY, 1.1};
+  std::vector<double> tsNaN = {0.45, stan::math::NOT_A_NUMBER};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a));
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
+                                          1e-10, 1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
+                                       1e-10, 1e6, nullptr, a),
+               std::invalid_argument);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_early, 1e-10,
+                                       1e-10, 1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_decreasing, 1e-10,
+                                       1e-10, 1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, tsinf, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, tsNaN, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_adams_tol_prim, one_arg_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+  double ainf = stan::math::INFTY;
+  double aNaN = stan::math::NOT_A_NUMBER;
+
+  std::vector<double> va = {a};
+  std::vector<double> vainf = {ainf};
+  std::vector<double> vaNaN = {aNaN};
+
+  Eigen::VectorXd ea(1);
+  ea << a;
+  Eigen::VectorXd eainf(1);
+  eainf << ainf;
+  Eigen::VectorXd eaNaN(1);
+  eaNaN << aNaN;
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, ainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, aNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, va));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, vainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, vaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, ea));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, eainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, eaNaN),
+               std::domain_error);
+}
+
+TEST(ode_adams_tol_prim, two_arg_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+  double ainf = stan::math::INFTY;
+  double aNaN = stan::math::NOT_A_NUMBER;
+
+  std::vector<double> va = {a};
+  std::vector<double> vainf = {ainf};
+  std::vector<double> vaNaN = {aNaN};
+
+  Eigen::VectorXd ea(1);
+  ea << a;
+  Eigen::VectorXd eainf(1);
+  eainf << ainf;
+  Eigen::VectorXd eaNaN(1);
+  eaNaN << aNaN;
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a, a));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, ainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, aNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a, va));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, vainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, vaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a, ea));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, eainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, eaNaN),
+               std::domain_error);
+}
+
+TEST(ode_adams_tol_prim, rtol_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double rtol = 1e-6;
+  double rtol_negative = -1e-6;
+  double rtolinf = stan::math::INFTY;
+  double rtolNaN = stan::math::NOT_A_NUMBER;
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, rtol, 1e-10,
+                                          1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, rtol_negative,
+                                       1e-10, 1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, rtolinf, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, rtolNaN, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_adams_tol_prim, atol_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double atol = 1e-6;
+  double atol_negative = -1e-6;
+  double atolinf = stan::math::INFTY;
+  double atolNaN = stan::math::NOT_A_NUMBER;
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, atol,
+                                          1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6,
+                                       atol_negative, 1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, atolinf,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, atolNaN,
+                                       1e6, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_adams_tol_prim, max_num_steps_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  int max_num_steps = 500;
+  int max_num_steps_negative = -500;
+  int max_num_steps_zero = 0;
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                          max_num_steps, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                       max_num_steps_negative, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                       max_num_steps_zero, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_adams_tol_prim, rhs_wrong_size_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                          100, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArgWrongSize(), y0, t0, ts, 1e-6,
+                                       1e-6, 100, nullptr, a),
+               std::invalid_argument);
+}
diff --git a/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
new file mode 100644
index 00000000000..f440b41ea29
--- /dev/null
+++ b/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
@@ -0,0 +1,845 @@
+#include <stan/math/rev.hpp>
+#include <gtest/gtest.h>
+#include <iostream>
+#include <vector>
+
+using stan::math::var;
+
+template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
+T sum_(T arg) {
+  return arg;
+}
+
+template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
+auto sum_(EigMat&& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
+auto sum_(Vec&& arg) {
+  stan::scalar_type_t<Vec> sum = 0;
+  for (size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
+  }
+  return sum;
+}
+
+struct CosArg1 {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos(sum_(vec) * t);
+    return out;
+  }
+};
+
+struct Cos2Arg {
+  template <typename T0, typename T1, typename T2, typename T3>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a, const T3& b) const {
+    Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos((sum_(a) + sum_(b)) * t);
+    return out;
+  }
+};
+
+TEST(StanMathOde_ode_adams_tol, int_t0) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  int t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
+      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
+  EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
+}
+
+TEST(StanMathOde_ode_adams_tol, int_ts) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<int> ts = {1, 2};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
+      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
+  EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
+}
+
+TEST(StanMathOde_ode_adams_tol, t0) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  var t0 = 0.0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+}
+
+TEST(StanMathOde_ode_adams_tol, ts) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<var> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
+}
+
+TEST(StanMathOde_ode_adams_tol, ts_repeat) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<var> ts = {0.45, 0.45, 1.1, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[1].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[2][0].grad();
+
+  EXPECT_FLOAT_EQ(output[2][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[2].adj(), -0.0791208888);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[3][0].grad();
+
+  EXPECT_FLOAT_EQ(output[3][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[3].adj(), -0.0791208888);
+}
+
+TEST(StanMathOde_ode_adams_tol, scalar_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a = 1.5;
+
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_adams_tol, scalar_arg_multi_time) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  var a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0](0).grad();
+
+  EXPECT_FLOAT_EQ(output[0](0).val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(a.adj(), -0.04352005542);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1](0).grad();
+
+  EXPECT_FLOAT_EQ(output[1](0).val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_adams_tol, std_vector_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  std::vector<var> a = {1.5};
+
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a[0].adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_adams_tol, vector_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
+  a << 1.5;
+
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_adams_tol, row_vector_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
+  a << 1.5;
+
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_adams_tol, matrix_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
+  a << 1.5;
+
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0, 0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_adams_tol, scalar_std_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 0.75;
+  std::vector<var> a1 = {0.75};
+
+  var output = stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a0, a1)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a0.adj(), -0.50107310888);
+  EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
+}
+
+struct ayt {
+  template <typename T0, typename T1, typename T2>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a) const {
+    return -a * y * t;
+  }
+};
+
+TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
+  var t0 = 0.5;
+  var a = 0.2;
+  std::vector<var> ts = {1.25};
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
+  y0 << 0.75;
+
+  double t0d = stan::math::value_of(t0);
+  double ad = stan::math::value_of(a);
+  std::vector<double> tsd = stan::math::value_of(ts);
+  Eigen::VectorXd y0d = stan::math::value_of(y0);
+
+  auto check_yT = [&](auto yT) {
+    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_t0 = [&](var t0) {
+    EXPECT_FLOAT_EQ(
+        t0.adj(),
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_a = [&](var a) {
+    EXPECT_FLOAT_EQ(a.adj(),
+                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_ts = [&](std::vector<var> ts) {
+    EXPECT_FLOAT_EQ(
+        ts[0].adj(),
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
+    EXPECT_FLOAT_EQ(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  double yT1 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                       nullptr, ad)[0](0);
+  check_yT(yT1);
+
+  var yT2 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT2.grad();
+  check_yT(yT2);
+  check_a(a);
+
+  var yT3 = stan::math::ode_adams_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT3.grad();
+  check_yT(yT3);
+  check_ts(ts);
+
+  var yT4 = stan::math::ode_adams_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT4.grad();
+  check_yT(yT4);
+  check_ts(ts);
+  check_a(a);
+
+  var yT5 = stan::math::ode_adams_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT5.grad();
+  check_yT(yT5);
+  check_t0(t0);
+
+  var yT6 = stan::math::ode_adams_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT6.grad();
+  check_yT(yT6);
+  check_t0(t0);
+  check_a(a);
+
+  var yT7 = stan::math::ode_adams_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT7.grad();
+  check_yT(yT7);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT8 = stan::math::ode_adams_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT8.grad();
+  check_yT(yT8);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT9 = stan::math::ode_adams_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT9.grad();
+  check_yT(yT9);
+  check_y0(y0);
+
+  var yT10 = stan::math::ode_adams_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT10.grad();
+  check_yT(yT10);
+  check_y0(y0);
+  check_a(a);
+
+  var yT11 = stan::math::ode_adams_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT11.grad();
+  check_yT(yT11);
+  check_y0(y0);
+  check_ts(ts);
+
+  var yT12 = stan::math::ode_adams_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT12.grad();
+  check_yT(yT12);
+  check_y0(y0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT13 = stan::math::ode_adams_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT13.grad();
+  check_yT(yT13);
+  check_y0(y0);
+  check_t0(t0);
+
+  var yT14 = stan::math::ode_adams_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT14.grad();
+  check_yT(yT14);
+  check_y0(y0);
+  check_t0(t0);
+  check_a(a);
+
+  var yT15 = stan::math::ode_adams_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT15.grad();
+  check_yT(yT15);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT16 = stan::math::ode_adams_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT16.grad();
+  check_yT(yT16);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+}
+
+TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
+  var t0 = 0.5;
+  var a = 0.2;
+  std::vector<var> ts = {1.25};
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
+  y0 << 0.75;
+
+  double t0d = stan::math::value_of(t0);
+  double ad = stan::math::value_of(a);
+  std::vector<double> tsd = stan::math::value_of(ts);
+  Eigen::VectorXd y0d = stan::math::value_of(y0);
+
+  auto check_yT = [&](auto yT) {
+    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_t0 = [&](var t0) {
+    EXPECT_FLOAT_EQ(
+        t0.adj(),
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_a = [&](var a) {
+    EXPECT_FLOAT_EQ(a.adj(),
+                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_ts = [&](std::vector<var> ts) {
+    EXPECT_FLOAT_EQ(
+        ts[0].adj(),
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
+    EXPECT_FLOAT_EQ(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  double yT1 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                             1e6, nullptr, ad)[0](0);
+  check_yT(yT1);
+
+  var yT2 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                          1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT2.grad();
+  check_yT(yT2);
+  check_a(a);
+
+  var yT3 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT3.grad();
+  check_yT(yT3);
+  check_ts(ts);
+
+  var yT4 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT4.grad();
+  check_yT(yT4);
+  check_ts(ts);
+  check_a(a);
+
+  var yT5 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
+                                          1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT5.grad();
+  check_yT(yT5);
+  check_t0(t0);
+
+  var yT6 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
+                                          1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT6.grad();
+  check_yT(yT6);
+  check_t0(t0);
+  check_a(a);
+
+  var yT7 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                          nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT7.grad();
+  check_yT(yT7);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT8 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                          nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT8.grad();
+  check_yT(yT8);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT9 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
+                                          1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT9.grad();
+  check_yT(yT9);
+  check_y0(y0);
+
+  var yT10 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
+                                           1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT10.grad();
+  check_yT(yT10);
+  check_y0(y0);
+  check_a(a);
+
+  var yT11 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT11.grad();
+  check_yT(yT11);
+  check_y0(y0);
+  check_ts(ts);
+
+  var yT12 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT12.grad();
+  check_yT(yT12);
+  check_y0(y0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT13 = stan::math::ode_adams_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
+                                           1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT13.grad();
+  check_yT(yT13);
+  check_y0(y0);
+  check_t0(t0);
+
+  var yT14 = stan::math::ode_adams_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
+                                           1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT14.grad();
+  check_yT(yT14);
+  check_y0(y0);
+  check_t0(t0);
+  check_a(a);
+
+  var yT15 = stan::math::ode_adams_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                           nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT15.grad();
+  check_yT(yT15);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT16 = stan::math::ode_adams_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                           nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT16.grad();
+  check_yT(yT16);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+}
+
+TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
+  var t0 = 0.5;
+  var a = 0.2;
+  std::vector<var> ts = {1.25};
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
+  y0 << 0.75;
+
+  double t0d = stan::math::value_of(t0);
+  double ad = stan::math::value_of(a);
+  std::vector<double> tsd = stan::math::value_of(ts);
+  Eigen::VectorXd y0d = stan::math::value_of(y0);
+
+  auto check_yT = [&](auto yT) {
+    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_t0 = [&](var t0) {
+    EXPECT_FLOAT_EQ(
+        t0.adj(),
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_a = [&](var a) {
+    EXPECT_FLOAT_EQ(a.adj(),
+                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_ts = [&](std::vector<var> ts) {
+    EXPECT_FLOAT_EQ(
+        ts[0].adj(),
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
+    EXPECT_FLOAT_EQ(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  double yT1 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {}, 1e6, nullptr, ad)[0](0);
+  check_yT(yT1);
+
+  var yT2 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT2.grad();
+  check_yT(yT2);
+  check_a(a);
+
+  var yT3 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {}, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT3.grad();
+  check_yT(yT3);
+  check_ts(ts);
+
+  var yT4 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT4.grad();
+  check_yT(yT4);
+  check_ts(ts);
+  check_a(a);
+
+  var yT5 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT5.grad();
+  check_yT(yT5);
+  check_t0(t0);
+
+  var yT6 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10,
+                                               1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
+                                               nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT6.grad();
+  check_yT(yT6);
+  check_t0(t0);
+  check_a(a);
+
+  var yT7 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT7.grad();
+  check_yT(yT7);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT8 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, ts, 1e-10, 1e-10,
+                                               1e-6, {1e-6, 1e-6}, 1e6, nullptr,
+                                               a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT8.grad();
+  check_yT(yT8);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT9 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT9.grad();
+  check_yT(yT9);
+  check_y0(y0);
+
+  var yT10 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10,
+                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
+                                                nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT10.grad();
+  check_yT(yT10);
+  check_y0(y0);
+  check_a(a);
+
+  var yT11 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT11.grad();
+  check_yT(yT11);
+  check_y0(y0);
+  check_ts(ts);
+
+  var yT12 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, ts, 1e-10,
+                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
+                                                nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT12.grad();
+  check_yT(yT12);
+  check_y0(y0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT13 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT13.grad();
+  check_yT(yT13);
+  check_y0(y0);
+  check_t0(t0);
+
+  var yT14 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, tsd, 1e-10,
+                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
+                                                nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT14.grad();
+  check_yT(yT14);
+  check_y0(y0);
+  check_t0(t0);
+  check_a(a);
+
+  var yT15 = stan::math::ode_adams_tol_sens_error(
+      ayt(), y0, t0, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT15.grad();
+  check_yT(yT15);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT16 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, ts, 1e-10, 1e-10,
+                                                1e-6, {1e-6, 1e-6}, 1e6,
+                                                nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT16.grad();
+  check_yT(yT16);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+
+  EXPECT_THROW(
+      stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                         1e-6, {1e-6, 1e-6}, 1e6, nullptr, a),
+      std::invalid_argument);
+
+  EXPECT_THROW(
+      stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                         -1e-6, {1e-6}, 1e6, nullptr, a),
+      std::domain_error);
+
+  EXPECT_THROW(
+      stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                         -1e-6, {-1e-6}, 1e6, nullptr, a),
+      std::domain_error);
+}
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index 81fa71affa2..74dca59d4be 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -1,14 +1,7 @@
 #include <stan/math/rev.hpp>
-#include <boost/numeric/odeint.hpp>
 #include <gtest/gtest.h>
-#include <test/unit/util.hpp>
 #include <iostream>
-#include <sstream>
 #include <vector>
-#include <limits>
-#include <string>
-
-using stan::math::var;
 
 template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
 T sum_(T arg) {
@@ -78,19 +71,15 @@ TEST(ode_bdf_prim, y0_errors) {
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0inf, t0, ts, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0inf, t0, ts, nullptr, a),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0NaN, t0, ts, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0NaN, t0, ts, nullptr, a),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0_empty, t0, ts, 1e-10,
-                                       1e-10, 1e6, nullptr, a),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0_empty, t0, ts, nullptr, a),
                std::invalid_argument);
 }
 
@@ -103,15 +92,12 @@ TEST(ode_bdf_prim, t0_errors) {
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0inf, ts, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0inf, ts, nullptr, a),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0NaN, ts, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0NaN, ts, nullptr, a),
                std::domain_error);
 }
 
@@ -128,30 +114,28 @@ TEST(ode_bdf_prim, ts_errors) {
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a));
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
-                                          1e-10, 1e6, nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts_repeat, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
-                                       1e-10, 1e6, nullptr, a),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts_empty,
+				   nullptr, a),
                std::invalid_argument);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_early, 1e-10,
-                                       1e-10, 1e6, nullptr, a),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts_early,
+				   nullptr, a),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_decreasing, 1e-10,
-                                       1e-10, 1e6, nullptr, a),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts_decreasing,
+				   nullptr, a),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, tsinf, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, tsinf,
+				   nullptr, a),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, tsNaN, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, tsNaN,
+				   nullptr, a),
                std::domain_error);
 }
 
@@ -175,36 +159,36 @@ TEST(ode_bdf_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
+				      nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                        nullptr, ainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                        nullptr, aNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, va));
+  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
+				      nullptr, va));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                        nullptr, vainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                        nullptr, vaNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, ea));
+  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
+				      nullptr, ea));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                        nullptr, eainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                        nullptr, eaNaN),
                std::domain_error);
 }
@@ -229,119 +213,40 @@ TEST(ode_bdf_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
+				      nullptr, a, a));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
                                        nullptr, a, ainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
                                        nullptr, a, aNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a, va));
+  EXPECT_NO_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
+				      nullptr, a, va));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
                                        nullptr, a, vainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
                                        nullptr, a, vaNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a, ea));
+  EXPECT_NO_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
+				      nullptr, a, ea));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
                                        nullptr, a, eainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
                                        nullptr, a, eaNaN),
                std::domain_error);
 }
 
-TEST(ode_bdf_prim, rtol_errors) {
-  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
-  double t0 = 0;
-  std::vector<double> ts = {0.45, 1.1};
-
-  double rtol = 1e-6;
-  double rtol_negative = -1e-6;
-  double rtolinf = stan::math::INFTY;
-  double rtolNaN = stan::math::NOT_A_NUMBER;
-
-  double a = 1.5;
-
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtol, 1e-10,
-                                          1e6, nullptr, a));
-
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtol_negative,
-                                       1e-10, 1e6, nullptr, a),
-               std::domain_error);
-
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtolinf, 1e-10,
-                                       1e6, nullptr, a),
-               std::domain_error);
-
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtolNaN, 1e-10,
-                                       1e6, nullptr, a),
-               std::domain_error);
-}
-
-TEST(ode_bdf_prim, atol_errors) {
-  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
-  double t0 = 0;
-  std::vector<double> ts = {0.45, 1.1};
-
-  double atol = 1e-6;
-  double atol_negative = -1e-6;
-  double atolinf = stan::math::INFTY;
-  double atolNaN = stan::math::NOT_A_NUMBER;
-
-  double a = 1.5;
-
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atol,
-                                          1e6, nullptr, a));
-
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6,
-                                       atol_negative, 1e6, nullptr, a),
-               std::domain_error);
-
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atolinf,
-                                       1e6, nullptr, a),
-               std::domain_error);
-
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atolNaN,
-                                       1e6, nullptr, a),
-               std::domain_error);
-}
-
-TEST(ode_bdf_prim, max_num_steps_errors) {
-  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
-  double t0 = 0;
-  std::vector<double> ts = {0.45, 1.1};
-
-  int max_num_steps = 500;
-  int max_num_steps_negative = -500;
-  int max_num_steps_zero = 0;
-
-  double a = 1.5;
-
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                          max_num_steps, nullptr, a));
-
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                       max_num_steps_negative, nullptr, a),
-               std::domain_error);
-
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                       max_num_steps_zero, nullptr, a),
-               std::domain_error);
-}
-
 TEST(ode_bdf_prim, rhs_wrong_size_errors) {
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0;
@@ -349,10 +254,8 @@ TEST(ode_bdf_prim, rhs_wrong_size_errors) {
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                          100, nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArgWrongSize(), y0, t0, ts, 1e-6,
-                                       1e-6, 100, nullptr, a),
+  EXPECT_THROW(stan::math::ode_bdf(CosArgWrongSize(), y0, t0, ts, nullptr, a),
                std::invalid_argument);
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index 4d1df9680c4..b0505cc9723 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -1,12 +1,7 @@
 #include <stan/math/rev.hpp>
-#include <boost/numeric/odeint.hpp>
 #include <gtest/gtest.h>
-#include <test/unit/util.hpp>
 #include <iostream>
-#include <sstream>
 #include <vector>
-#include <limits>
-#include <string>
 
 using stan::math::var;
 
@@ -53,7 +48,7 @@ struct Cos2Arg {
   }
 };
 
-TEST(StanMathOde_ode_bdf_tol, int_t0) {
+TEST(StanMathOde_ode_bdf, int_t0) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -63,14 +58,14 @@ TEST(StanMathOde_ode_bdf_tol, int_t0) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
-      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+      = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                 nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
   EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
 }
 
-TEST(StanMathOde_ode_bdf_tol, int_ts) {
+TEST(StanMathOde_ode_bdf, int_ts) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -80,14 +75,14 @@ TEST(StanMathOde_ode_bdf_tol, int_ts) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
-      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+      = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                 nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
   EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
 }
 
-TEST(StanMathOde_ode_bdf_tol, t0) {
+TEST(StanMathOde_ode_bdf, t0) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -97,7 +92,7 @@ TEST(StanMathOde_ode_bdf_tol, t0) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+      = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                 nullptr, a);
 
   output[0][0].grad();
@@ -113,7 +108,7 @@ TEST(StanMathOde_ode_bdf_tol, t0) {
   EXPECT_FLOAT_EQ(t0.adj(), -1.0);
 }
 
-TEST(StanMathOde_ode_bdf_tol, ts) {
+TEST(StanMathOde_ode_bdf, ts) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -123,7 +118,7 @@ TEST(StanMathOde_ode_bdf_tol, ts) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+      = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                 nullptr, a);
 
   output[0][0].grad();
@@ -139,7 +134,7 @@ TEST(StanMathOde_ode_bdf_tol, ts) {
   EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
 }
 
-TEST(StanMathOde_ode_bdf_tol, ts_repeat) {
+TEST(StanMathOde_ode_bdf, ts_repeat) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -149,7 +144,7 @@ TEST(StanMathOde_ode_bdf_tol, ts_repeat) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+      = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                 nullptr, a);
 
   output[0][0].grad();
@@ -179,7 +174,7 @@ TEST(StanMathOde_ode_bdf_tol, ts_repeat) {
   EXPECT_FLOAT_EQ(ts[3].adj(), -0.0791208888);
 }
 
-TEST(StanMathOde_ode_bdf_tol, scalar_arg) {
+TEST(StanMathOde_ode_bdf, scalar_arg) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -188,7 +183,7 @@ TEST(StanMathOde_ode_bdf_tol, scalar_arg) {
 
   var a = 1.5;
 
-  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                        nullptr, a)[0][0];
 
   output.grad();
@@ -197,7 +192,7 @@ TEST(StanMathOde_ode_bdf_tol, scalar_arg) {
   EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_bdf_tol, scalar_arg_multi_time) {
+TEST(StanMathOde_ode_bdf, scalar_arg_multi_time) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -207,7 +202,7 @@ TEST(StanMathOde_ode_bdf_tol, scalar_arg_multi_time) {
   var a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+      = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                 nullptr, a);
 
   output[0](0).grad();
@@ -223,7 +218,7 @@ TEST(StanMathOde_ode_bdf_tol, scalar_arg_multi_time) {
   EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_bdf_tol, std_vector_arg) {
+TEST(StanMathOde_ode_bdf, std_vector_arg) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -232,7 +227,7 @@ TEST(StanMathOde_ode_bdf_tol, std_vector_arg) {
 
   std::vector<var> a = {1.5};
 
-  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                        nullptr, a)[0][0];
 
   output.grad();
@@ -241,7 +236,7 @@ TEST(StanMathOde_ode_bdf_tol, std_vector_arg) {
   EXPECT_FLOAT_EQ(a[0].adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_bdf_tol, vector_arg) {
+TEST(StanMathOde_ode_bdf, vector_arg) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -251,7 +246,7 @@ TEST(StanMathOde_ode_bdf_tol, vector_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                        nullptr, a)[0][0];
 
   output.grad();
@@ -260,7 +255,7 @@ TEST(StanMathOde_ode_bdf_tol, vector_arg) {
   EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_bdf_tol, row_vector_arg) {
+TEST(StanMathOde_ode_bdf, row_vector_arg) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -270,7 +265,7 @@ TEST(StanMathOde_ode_bdf_tol, row_vector_arg) {
   Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                        nullptr, a)[0][0];
 
   output.grad();
@@ -279,7 +274,7 @@ TEST(StanMathOde_ode_bdf_tol, row_vector_arg) {
   EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_bdf_tol, matrix_arg) {
+TEST(StanMathOde_ode_bdf, matrix_arg) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -289,7 +284,7 @@ TEST(StanMathOde_ode_bdf_tol, matrix_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
   a << 1.5;
 
-  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
                                        nullptr, a)[0][0];
 
   output.grad();
@@ -298,7 +293,7 @@ TEST(StanMathOde_ode_bdf_tol, matrix_arg) {
   EXPECT_FLOAT_EQ(a(0, 0).adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_bdf_tol, scalar_std_vector_args) {
+TEST(StanMathOde_ode_bdf, scalar_std_vector_args) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -308,7 +303,7 @@ TEST(StanMathOde_ode_bdf_tol, scalar_std_vector_args) {
   var a0 = 0.75;
   std::vector<var> a1 = {0.75};
 
-  var output = stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+  var output = stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
                                        nullptr, a0, a1)[0][0];
 
   output.grad();
@@ -327,7 +322,7 @@ struct ayt {
   }
 };
 
-TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
+TEST(StanMathOde_ode_bdf, arg_combos_test) {
   var t0 = 0.5;
   var a = 0.2;
   std::vector<var> ts = {1.25};
@@ -367,25 +362,25 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
                     exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
-  double yT1 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+  double yT1 = stan::math::ode_bdf(ayt(), y0d, t0d, tsd,
                                        nullptr, ad)[0](0);
   check_yT(yT1);
 
-  var yT2 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+  var yT2 = stan::math::ode_bdf(ayt(), y0d, t0d, tsd,
                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
-  var yT3 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+  var yT3 = stan::math::ode_bdf(ayt(), y0d, t0d, ts,
                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
-  var yT4 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+  var yT4 = stan::math::ode_bdf(ayt(), y0d, t0d, ts,
                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
@@ -393,14 +388,14 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT5 = stan::math::ode_bdf_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+  var yT5 = stan::math::ode_bdf(ayt(), y0d, t0, tsd,
                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
-  var yT6 = stan::math::ode_bdf_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+  var yT6 = stan::math::ode_bdf(ayt(), y0d, t0, tsd,
                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
@@ -408,7 +403,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_t0(t0);
   check_a(a);
 
-  var yT7 = stan::math::ode_bdf_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+  var yT7 = stan::math::ode_bdf(ayt(), y0d, t0, ts,
                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
@@ -416,7 +411,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_t0(t0);
   check_ts(ts);
 
-  var yT8 = stan::math::ode_bdf_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+  var yT8 = stan::math::ode_bdf(ayt(), y0d, t0, ts,
                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
@@ -425,14 +420,14 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT9 = stan::math::ode_bdf_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+  var yT9 = stan::math::ode_bdf(ayt(), y0, t0d, tsd,
                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
-  var yT10 = stan::math::ode_bdf_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+  var yT10 = stan::math::ode_bdf(ayt(), y0, t0d, tsd,
                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
@@ -440,7 +435,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_y0(y0);
   check_a(a);
 
-  var yT11 = stan::math::ode_bdf_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+  var yT11 = stan::math::ode_bdf(ayt(), y0, t0d, ts,
                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
@@ -448,7 +443,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_y0(y0);
   check_ts(ts);
 
-  var yT12 = stan::math::ode_bdf_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+  var yT12 = stan::math::ode_bdf(ayt(), y0, t0d, ts,
                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
@@ -457,7 +452,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT13 = stan::math::ode_bdf_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+  var yT13 = stan::math::ode_bdf(ayt(), y0, t0, tsd,
                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
@@ -465,7 +460,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_y0(y0);
   check_t0(t0);
 
-  var yT14 = stan::math::ode_bdf_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+  var yT14 = stan::math::ode_bdf(ayt(), y0, t0, tsd,
                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
@@ -474,7 +469,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_t0(t0);
   check_a(a);
 
-  var yT15 = stan::math::ode_bdf_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+  var yT15 = stan::math::ode_bdf(ayt(), y0, t0, ts,
                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
@@ -483,7 +478,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_t0(t0);
   check_ts(ts);
 
-  var yT16 = stan::math::ode_bdf_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+  var yT16 = stan::math::ode_bdf(ayt(), y0, t0, ts,
                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
@@ -493,358 +488,3 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 }
-
-TEST(StanMathOde_ode_bdf_tol, arg_combos_error_test) {
-  var t0 = 0.5;
-  var a = 0.2;
-  std::vector<var> ts = {1.25};
-  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
-  y0 << 0.75;
-
-  double t0d = stan::math::value_of(t0);
-  double ad = stan::math::value_of(a);
-  std::vector<double> tsd = stan::math::value_of(ts);
-  Eigen::VectorXd y0d = stan::math::value_of(y0);
-
-  auto check_yT = [&](auto yT) {
-    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
-                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_t0 = [&](var t0) {
-    EXPECT_FLOAT_EQ(
-        t0.adj(),
-        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_a = [&](var a) {
-    EXPECT_FLOAT_EQ(a.adj(),
-                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
-                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_ts = [&](std::vector<var> ts) {
-    EXPECT_FLOAT_EQ(
-        ts[0].adj(),
-        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
-    EXPECT_FLOAT_EQ(y0(0).adj(),
-                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  double yT1 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                             1e6, nullptr, ad)[0](0);
-  check_yT(yT1);
-
-  var yT2 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                          1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT2.grad();
-  check_yT(yT2);
-  check_a(a);
-
-  var yT3 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT3.grad();
-  check_yT(yT3);
-  check_ts(ts);
-
-  var yT4 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT4.grad();
-  check_yT(yT4);
-  check_ts(ts);
-  check_a(a);
-
-  var yT5 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
-                                          1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT5.grad();
-  check_yT(yT5);
-  check_t0(t0);
-
-  var yT6 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
-                                          1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT6.grad();
-  check_yT(yT6);
-  check_t0(t0);
-  check_a(a);
-
-  var yT7 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                          nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT7.grad();
-  check_yT(yT7);
-  check_t0(t0);
-  check_ts(ts);
-
-  var yT8 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                          nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT8.grad();
-  check_yT(yT8);
-  check_t0(t0);
-  check_ts(ts);
-  check_a(a);
-
-  var yT9 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
-                                          1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT9.grad();
-  check_yT(yT9);
-  check_y0(y0);
-
-  var yT10 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
-                                           1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT10.grad();
-  check_yT(yT10);
-  check_y0(y0);
-  check_a(a);
-
-  var yT11 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT11.grad();
-  check_yT(yT11);
-  check_y0(y0);
-  check_ts(ts);
-
-  var yT12 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT12.grad();
-  check_yT(yT12);
-  check_y0(y0);
-  check_ts(ts);
-  check_a(a);
-
-  var yT13 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
-                                           1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT13.grad();
-  check_yT(yT13);
-  check_y0(y0);
-  check_t0(t0);
-
-  var yT14 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
-                                           1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT14.grad();
-  check_yT(yT14);
-  check_y0(y0);
-  check_t0(t0);
-  check_a(a);
-
-  var yT15 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                           nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT15.grad();
-  check_yT(yT15);
-  check_y0(y0);
-  check_t0(t0);
-  check_ts(ts);
-
-  var yT16 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                           nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT16.grad();
-  check_yT(yT16);
-  check_y0(y0);
-  check_t0(t0);
-  check_ts(ts);
-  check_a(a);
-}
-
-TEST(StanMathOde_ode_bdf_tol, arg_combos_sens_error_test) {
-  var t0 = 0.5;
-  var a = 0.2;
-  std::vector<var> ts = {1.25};
-  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
-  y0 << 0.75;
-
-  double t0d = stan::math::value_of(t0);
-  double ad = stan::math::value_of(a);
-  std::vector<double> tsd = stan::math::value_of(ts);
-  Eigen::VectorXd y0d = stan::math::value_of(y0);
-
-  auto check_yT = [&](auto yT) {
-    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
-                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_t0 = [&](var t0) {
-    EXPECT_FLOAT_EQ(
-        t0.adj(),
-        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_a = [&](var a) {
-    EXPECT_FLOAT_EQ(a.adj(),
-                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
-                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_ts = [&](std::vector<var> ts) {
-    EXPECT_FLOAT_EQ(
-        ts[0].adj(),
-        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
-    EXPECT_FLOAT_EQ(y0(0).adj(),
-                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  double yT1 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {}, 1e6, nullptr, ad)[0](0);
-  check_yT(yT1);
-
-  var yT2 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT2.grad();
-  check_yT(yT2);
-  check_a(a);
-
-  var yT3 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {}, 1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT3.grad();
-  check_yT(yT3);
-  check_ts(ts);
-
-  var yT4 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT4.grad();
-  check_yT(yT4);
-  check_ts(ts);
-  check_a(a);
-
-  var yT5 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT5.grad();
-  check_yT(yT5);
-  check_t0(t0);
-
-  var yT6 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10,
-                                               1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
-                                               nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT6.grad();
-  check_yT(yT6);
-  check_t0(t0);
-  check_a(a);
-
-  var yT7 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT7.grad();
-  check_yT(yT7);
-  check_t0(t0);
-  check_ts(ts);
-
-  var yT8 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0, ts, 1e-10, 1e-10,
-                                               1e-6, {1e-6, 1e-6}, 1e6, nullptr,
-                                               a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT8.grad();
-  check_yT(yT8);
-  check_t0(t0);
-  check_ts(ts);
-  check_a(a);
-
-  var yT9 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT9.grad();
-  check_yT(yT9);
-  check_y0(y0);
-
-  var yT10 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10,
-                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
-                                                nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT10.grad();
-  check_yT(yT10);
-  check_y0(y0);
-  check_a(a);
-
-  var yT11 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT11.grad();
-  check_yT(yT11);
-  check_y0(y0);
-  check_ts(ts);
-
-  var yT12 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0d, ts, 1e-10,
-                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
-                                                nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT12.grad();
-  check_yT(yT12);
-  check_y0(y0);
-  check_ts(ts);
-  check_a(a);
-
-  var yT13 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT13.grad();
-  check_yT(yT13);
-  check_y0(y0);
-  check_t0(t0);
-
-  var yT14 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0, tsd, 1e-10,
-                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
-                                                nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT14.grad();
-  check_yT(yT14);
-  check_y0(y0);
-  check_t0(t0);
-  check_a(a);
-
-  var yT15 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0, t0, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT15.grad();
-  check_yT(yT15);
-  check_y0(y0);
-  check_t0(t0);
-  check_ts(ts);
-
-  var yT16 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0, ts, 1e-10, 1e-10,
-                                                1e-6, {1e-6, 1e-6}, 1e6,
-                                                nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT16.grad();
-  check_yT(yT16);
-  check_y0(y0);
-  check_t0(t0);
-  check_ts(ts);
-  check_a(a);
-
-  EXPECT_THROW(
-      stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                         1e-6, {1e-6, 1e-6}, 1e6, nullptr, a),
-      std::invalid_argument);
-
-  EXPECT_THROW(
-      stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                         -1e-6, {1e-6}, 1e6, nullptr, a),
-      std::domain_error);
-
-  EXPECT_THROW(
-      stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                         -1e-6, {-1e-6}, 1e6, nullptr, a),
-      std::domain_error);
-}
diff --git a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
new file mode 100644
index 00000000000..33242f813cc
--- /dev/null
+++ b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
@@ -0,0 +1,351 @@
+#include <stan/math/rev.hpp>
+#include <gtest/gtest.h>
+#include <iostream>
+#include <vector>
+
+template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
+T sum_(T arg) {
+  return arg;
+}
+
+template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
+auto sum_(EigMat&& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
+auto sum_(Vec&& arg) {
+  stan::scalar_type_t<Vec> sum = 0;
+  for (size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
+  }
+  return sum;
+}
+
+struct CosArg1 {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos(sum_(vec) * t);
+    return out;
+  }
+};
+
+struct Cos2Arg {
+  template <typename T0, typename T1, typename T2, typename T3>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a, const T3& b) const {
+    Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos((sum_(a) + sum_(b)) * t);
+    return out;
+  }
+};
+
+struct CosArgWrongSize {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(2);
+    out << stan::math::cos(sum_(vec) * t), 0;
+    return out;
+  }
+};
+
+TEST(ode_bdf_prim, y0_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  Eigen::VectorXd y0inf(1);
+  Eigen::VectorXd y0NaN(1);
+  Eigen::VectorXd y0_empty;
+  y0NaN << stan::math::NOT_A_NUMBER;
+  y0inf << stan::math::INFTY;
+  int t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0inf, t0, ts, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0NaN, t0, ts, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0_empty, t0, ts, 1e-10,
+                                       1e-10, 1e6, nullptr, a),
+               std::invalid_argument);
+}
+
+TEST(ode_bdf_prim, t0_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  double t0inf = stan::math::INFTY;
+  double t0NaN = stan::math::NOT_A_NUMBER;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0inf, ts, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0NaN, ts, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_bdf_prim, ts_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+  std::vector<double> ts_repeat = {0.45, 0.45};
+  std::vector<double> ts_empty = {};
+  std::vector<double> ts_early = {-0.45, 0.2};
+  std::vector<double> ts_decreasing = {0.45, 0.2};
+  std::vector<double> tsinf = {stan::math::INFTY, 1.1};
+  std::vector<double> tsNaN = {0.45, stan::math::NOT_A_NUMBER};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a));
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
+                                          1e-10, 1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
+                                       1e-10, 1e6, nullptr, a),
+               std::invalid_argument);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_early, 1e-10,
+                                       1e-10, 1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_decreasing, 1e-10,
+                                       1e-10, 1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, tsinf, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, tsNaN, 1e-10, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_bdf_prim, one_arg_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+  double ainf = stan::math::INFTY;
+  double aNaN = stan::math::NOT_A_NUMBER;
+
+  std::vector<double> va = {a};
+  std::vector<double> vainf = {ainf};
+  std::vector<double> vaNaN = {aNaN};
+
+  Eigen::VectorXd ea(1);
+  ea << a;
+  Eigen::VectorXd eainf(1);
+  eainf << ainf;
+  Eigen::VectorXd eaNaN(1);
+  eaNaN << aNaN;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, ainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, aNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, va));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, vainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, vaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, ea));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, eainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, eaNaN),
+               std::domain_error);
+}
+
+TEST(ode_bdf_prim, two_arg_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+  double ainf = stan::math::INFTY;
+  double aNaN = stan::math::NOT_A_NUMBER;
+
+  std::vector<double> va = {a};
+  std::vector<double> vainf = {ainf};
+  std::vector<double> vaNaN = {aNaN};
+
+  Eigen::VectorXd ea(1);
+  ea << a;
+  Eigen::VectorXd eainf(1);
+  eainf << ainf;
+  Eigen::VectorXd eaNaN(1);
+  eaNaN << aNaN;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, ainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, aNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a, va));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, vainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, vaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a, ea));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, eainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, eaNaN),
+               std::domain_error);
+}
+
+TEST(ode_bdf_prim, rtol_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double rtol = 1e-6;
+  double rtol_negative = -1e-6;
+  double rtolinf = stan::math::INFTY;
+  double rtolNaN = stan::math::NOT_A_NUMBER;
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtol, 1e-10,
+                                          1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtol_negative,
+                                       1e-10, 1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtolinf, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtolNaN, 1e-10,
+                                       1e6, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_bdf_prim, atol_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double atol = 1e-6;
+  double atol_negative = -1e-6;
+  double atolinf = stan::math::INFTY;
+  double atolNaN = stan::math::NOT_A_NUMBER;
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atol,
+                                          1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6,
+                                       atol_negative, 1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atolinf,
+                                       1e6, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atolNaN,
+                                       1e6, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_bdf_prim, max_num_steps_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  int max_num_steps = 500;
+  int max_num_steps_negative = -500;
+  int max_num_steps_zero = 0;
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                          max_num_steps, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                       max_num_steps_negative, nullptr, a),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                       max_num_steps_zero, nullptr, a),
+               std::domain_error);
+}
+
+TEST(ode_bdf_prim, rhs_wrong_size_errors) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                          100, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArgWrongSize(), y0, t0, ts, 1e-6,
+                                       1e-6, 100, nullptr, a),
+               std::invalid_argument);
+}
diff --git a/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
new file mode 100644
index 00000000000..f88e442711a
--- /dev/null
+++ b/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
@@ -0,0 +1,845 @@
+#include <stan/math/rev.hpp>
+#include <gtest/gtest.h>
+#include <iostream>
+#include <vector>
+
+using stan::math::var;
+
+template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
+T sum_(T arg) {
+  return arg;
+}
+
+template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
+auto sum_(EigMat&& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
+auto sum_(Vec&& arg) {
+  stan::scalar_type_t<Vec> sum = 0;
+  for (size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
+  }
+  return sum;
+}
+
+struct CosArg1 {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos(sum_(vec) * t);
+    return out;
+  }
+};
+
+struct Cos2Arg {
+  template <typename T0, typename T1, typename T2, typename T3>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a, const T3& b) const {
+    Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos((sum_(a) + sum_(b)) * t);
+    return out;
+  }
+};
+
+TEST(StanMathOde_ode_bdf_tol, int_t0) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  int t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
+      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
+  EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
+}
+
+TEST(StanMathOde_ode_bdf_tol, int_ts) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<int> ts = {1, 2};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
+      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
+  EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
+}
+
+TEST(StanMathOde_ode_bdf_tol, t0) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  var t0 = 0.0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+}
+
+TEST(StanMathOde_ode_bdf_tol, ts) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<var> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
+}
+
+TEST(StanMathOde_ode_bdf_tol, ts_repeat) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<var> ts = {0.45, 0.45, 1.1, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[1].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[2][0].grad();
+
+  EXPECT_FLOAT_EQ(output[2][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[2].adj(), -0.0791208888);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[3][0].grad();
+
+  EXPECT_FLOAT_EQ(output[3][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[3].adj(), -0.0791208888);
+}
+
+TEST(StanMathOde_ode_bdf_tol, scalar_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a = 1.5;
+
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_bdf_tol, scalar_arg_multi_time) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  var a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0](0).grad();
+
+  EXPECT_FLOAT_EQ(output[0](0).val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(a.adj(), -0.04352005542);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1](0).grad();
+
+  EXPECT_FLOAT_EQ(output[1](0).val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_bdf_tol, std_vector_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  std::vector<var> a = {1.5};
+
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a[0].adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_bdf_tol, vector_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
+  a << 1.5;
+
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_bdf_tol, row_vector_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
+  a << 1.5;
+
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_bdf_tol, matrix_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
+  a << 1.5;
+
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0, 0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_bdf_tol, scalar_std_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 0.75;
+  std::vector<var> a1 = {0.75};
+
+  var output = stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a0, a1)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a0.adj(), -0.50107310888);
+  EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
+}
+
+struct ayt {
+  template <typename T0, typename T1, typename T2>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a) const {
+    return -a * y * t;
+  }
+};
+
+TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
+  var t0 = 0.5;
+  var a = 0.2;
+  std::vector<var> ts = {1.25};
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
+  y0 << 0.75;
+
+  double t0d = stan::math::value_of(t0);
+  double ad = stan::math::value_of(a);
+  std::vector<double> tsd = stan::math::value_of(ts);
+  Eigen::VectorXd y0d = stan::math::value_of(y0);
+
+  auto check_yT = [&](auto yT) {
+    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_t0 = [&](var t0) {
+    EXPECT_FLOAT_EQ(
+        t0.adj(),
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_a = [&](var a) {
+    EXPECT_FLOAT_EQ(a.adj(),
+                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_ts = [&](std::vector<var> ts) {
+    EXPECT_FLOAT_EQ(
+        ts[0].adj(),
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
+    EXPECT_FLOAT_EQ(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  double yT1 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                       nullptr, ad)[0](0);
+  check_yT(yT1);
+
+  var yT2 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT2.grad();
+  check_yT(yT2);
+  check_a(a);
+
+  var yT3 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT3.grad();
+  check_yT(yT3);
+  check_ts(ts);
+
+  var yT4 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT4.grad();
+  check_yT(yT4);
+  check_ts(ts);
+  check_a(a);
+
+  var yT5 = stan::math::ode_bdf_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT5.grad();
+  check_yT(yT5);
+  check_t0(t0);
+
+  var yT6 = stan::math::ode_bdf_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT6.grad();
+  check_yT(yT6);
+  check_t0(t0);
+  check_a(a);
+
+  var yT7 = stan::math::ode_bdf_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT7.grad();
+  check_yT(yT7);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT8 = stan::math::ode_bdf_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT8.grad();
+  check_yT(yT8);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT9 = stan::math::ode_bdf_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT9.grad();
+  check_yT(yT9);
+  check_y0(y0);
+
+  var yT10 = stan::math::ode_bdf_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT10.grad();
+  check_yT(yT10);
+  check_y0(y0);
+  check_a(a);
+
+  var yT11 = stan::math::ode_bdf_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT11.grad();
+  check_yT(yT11);
+  check_y0(y0);
+  check_ts(ts);
+
+  var yT12 = stan::math::ode_bdf_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT12.grad();
+  check_yT(yT12);
+  check_y0(y0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT13 = stan::math::ode_bdf_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT13.grad();
+  check_yT(yT13);
+  check_y0(y0);
+  check_t0(t0);
+
+  var yT14 = stan::math::ode_bdf_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT14.grad();
+  check_yT(yT14);
+  check_y0(y0);
+  check_t0(t0);
+  check_a(a);
+
+  var yT15 = stan::math::ode_bdf_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT15.grad();
+  check_yT(yT15);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT16 = stan::math::ode_bdf_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT16.grad();
+  check_yT(yT16);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+}
+
+TEST(StanMathOde_ode_bdf_tol, arg_combos_error_test) {
+  var t0 = 0.5;
+  var a = 0.2;
+  std::vector<var> ts = {1.25};
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
+  y0 << 0.75;
+
+  double t0d = stan::math::value_of(t0);
+  double ad = stan::math::value_of(a);
+  std::vector<double> tsd = stan::math::value_of(ts);
+  Eigen::VectorXd y0d = stan::math::value_of(y0);
+
+  auto check_yT = [&](auto yT) {
+    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_t0 = [&](var t0) {
+    EXPECT_FLOAT_EQ(
+        t0.adj(),
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_a = [&](var a) {
+    EXPECT_FLOAT_EQ(a.adj(),
+                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_ts = [&](std::vector<var> ts) {
+    EXPECT_FLOAT_EQ(
+        ts[0].adj(),
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
+    EXPECT_FLOAT_EQ(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  double yT1 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                             1e6, nullptr, ad)[0](0);
+  check_yT(yT1);
+
+  var yT2 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                          1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT2.grad();
+  check_yT(yT2);
+  check_a(a);
+
+  var yT3 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT3.grad();
+  check_yT(yT3);
+  check_ts(ts);
+
+  var yT4 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
+                                          1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT4.grad();
+  check_yT(yT4);
+  check_ts(ts);
+  check_a(a);
+
+  var yT5 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
+                                          1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT5.grad();
+  check_yT(yT5);
+  check_t0(t0);
+
+  var yT6 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
+                                          1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT6.grad();
+  check_yT(yT6);
+  check_t0(t0);
+  check_a(a);
+
+  var yT7 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                          nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT7.grad();
+  check_yT(yT7);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT8 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                          nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT8.grad();
+  check_yT(yT8);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT9 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
+                                          1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT9.grad();
+  check_yT(yT9);
+  check_y0(y0);
+
+  var yT10 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
+                                           1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT10.grad();
+  check_yT(yT10);
+  check_y0(y0);
+  check_a(a);
+
+  var yT11 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT11.grad();
+  check_yT(yT11);
+  check_y0(y0);
+  check_ts(ts);
+
+  var yT12 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT12.grad();
+  check_yT(yT12);
+  check_y0(y0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT13 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
+                                           1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT13.grad();
+  check_yT(yT13);
+  check_y0(y0);
+  check_t0(t0);
+
+  var yT14 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
+                                           1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT14.grad();
+  check_yT(yT14);
+  check_y0(y0);
+  check_t0(t0);
+  check_a(a);
+
+  var yT15 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                           nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT15.grad();
+  check_yT(yT15);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT16 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                           nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT16.grad();
+  check_yT(yT16);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+}
+
+TEST(StanMathOde_ode_bdf_tol, arg_combos_sens_error_test) {
+  var t0 = 0.5;
+  var a = 0.2;
+  std::vector<var> ts = {1.25};
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
+  y0 << 0.75;
+
+  double t0d = stan::math::value_of(t0);
+  double ad = stan::math::value_of(a);
+  std::vector<double> tsd = stan::math::value_of(ts);
+  Eigen::VectorXd y0d = stan::math::value_of(y0);
+
+  auto check_yT = [&](auto yT) {
+    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_t0 = [&](var t0) {
+    EXPECT_FLOAT_EQ(
+        t0.adj(),
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_a = [&](var a) {
+    EXPECT_FLOAT_EQ(a.adj(),
+                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_ts = [&](std::vector<var> ts) {
+    EXPECT_FLOAT_EQ(
+        ts[0].adj(),
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
+    EXPECT_FLOAT_EQ(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  double yT1 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {}, 1e6, nullptr, ad)[0](0);
+  check_yT(yT1);
+
+  var yT2 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT2.grad();
+  check_yT(yT2);
+  check_a(a);
+
+  var yT3 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {}, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT3.grad();
+  check_yT(yT3);
+  check_ts(ts);
+
+  var yT4 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT4.grad();
+  check_yT(yT4);
+  check_ts(ts);
+  check_a(a);
+
+  var yT5 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT5.grad();
+  check_yT(yT5);
+  check_t0(t0);
+
+  var yT6 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10,
+                                               1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
+                                               nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT6.grad();
+  check_yT(yT6);
+  check_t0(t0);
+  check_a(a);
+
+  var yT7 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT7.grad();
+  check_yT(yT7);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT8 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0, ts, 1e-10, 1e-10,
+                                               1e-6, {1e-6, 1e-6}, 1e6, nullptr,
+                                               a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT8.grad();
+  check_yT(yT8);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT9 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT9.grad();
+  check_yT(yT9);
+  check_y0(y0);
+
+  var yT10 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10,
+                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
+                                                nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT10.grad();
+  check_yT(yT10);
+  check_y0(y0);
+  check_a(a);
+
+  var yT11 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT11.grad();
+  check_yT(yT11);
+  check_y0(y0);
+  check_ts(ts);
+
+  var yT12 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0d, ts, 1e-10,
+                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
+                                                nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT12.grad();
+  check_yT(yT12);
+  check_y0(y0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT13 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT13.grad();
+  check_yT(yT13);
+  check_y0(y0);
+  check_t0(t0);
+
+  var yT14 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0, tsd, 1e-10,
+                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
+                                                nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT14.grad();
+  check_yT(yT14);
+  check_y0(y0);
+  check_t0(t0);
+  check_a(a);
+
+  var yT15 = stan::math::ode_bdf_tol_sens_error(
+      ayt(), y0, t0, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT15.grad();
+  check_yT(yT15);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT16 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0, ts, 1e-10, 1e-10,
+                                                1e-6, {1e-6, 1e-6}, 1e6,
+                                                nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT16.grad();
+  check_yT(yT16);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+
+  EXPECT_THROW(
+      stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                         1e-6, {1e-6, 1e-6}, 1e6, nullptr, a),
+      std::invalid_argument);
+
+  EXPECT_THROW(
+      stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                         -1e-6, {1e-6}, 1e6, nullptr, a),
+      std::domain_error);
+
+  EXPECT_THROW(
+      stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                         -1e-6, {-1e-6}, 1e6, nullptr, a),
+      std::domain_error);
+}
diff --git a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
index f14e9fe5590..e97e6f43ef4 100644
--- a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
@@ -1,12 +1,7 @@
 #include <stan/math/rev.hpp>
-#include <boost/numeric/odeint.hpp>
 #include <gtest/gtest.h>
-#include <test/unit/util.hpp>
 #include <iostream>
-#include <sstream>
 #include <vector>
-#include <limits>
-#include <string>
 
 using stan::math::var;
 
@@ -31,13 +26,12 @@ auto sum_(Vec&& arg) {
 
 struct CosArg1 {
   template <typename T0, typename T1, typename... T_Args>
-  inline Eigen::Matrix<stan::return_type_t<T0, T1, T_Args...>, Eigen::Dynamic,
-                       1>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
   operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
              std::ostream* msgs, const T_Args&... a) const {
-    std::vector<typename stan::return_type<T_Args...>::type> vec = {sum_(a)...};
-    Eigen::Matrix<stan::return_type_t<T0, T1, T_Args...>, Eigen::Dynamic, 1>
-        out(1);
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(1);
     out << stan::math::cos(sum_(vec) * t);
     return out;
   }
@@ -45,18 +39,16 @@ struct CosArg1 {
 
 struct Cos2Arg {
   template <typename T0, typename T1, typename T2, typename T3>
-  inline Eigen::Matrix<typename stan::return_type<T1, T2, T3>::type,
-                       Eigen::Dynamic, 1>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1>
   operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
              std::ostream* msgs, const T2& a, const T3& b) const {
-    Eigen::Matrix<stan::return_type_t<T0, T1, T2, T3>, Eigen::Dynamic, 1> out(
-        1);
+    Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1> out(1);
     out << stan::math::cos((sum_(a) + sum_(b)) * t);
     return out;
   }
 };
 
-TEST(StanMathOde_ode_rk45_tol, int_t0) {
+TEST(StanMathOde_ode_rk45, int_t0) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -66,14 +58,14 @@ TEST(StanMathOde_ode_rk45_tol, int_t0) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
-      = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+      = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
   EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
 }
 
-TEST(StanMathOde_ode_rk45_tol, int_ts) {
+TEST(StanMathOde_ode_rk45, int_ts) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -83,14 +75,14 @@ TEST(StanMathOde_ode_rk45_tol, int_ts) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
-      = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+      = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
   EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
 }
 
-TEST(StanMathOde_ode_rk45_tol, t0) {
+TEST(StanMathOde_ode_rk45, t0) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -100,8 +92,8 @@ TEST(StanMathOde_ode_rk45_tol, t0) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+      = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                nullptr, a);
 
   output[0][0].grad();
 
@@ -116,7 +108,7 @@ TEST(StanMathOde_ode_rk45_tol, t0) {
   EXPECT_FLOAT_EQ(t0.adj(), -1.0);
 }
 
-TEST(StanMathOde_ode_rk45_tol, ts) {
+TEST(StanMathOde_ode_rk45, ts) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -126,8 +118,8 @@ TEST(StanMathOde_ode_rk45_tol, ts) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+      = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                nullptr, a);
 
   output[0][0].grad();
 
@@ -142,7 +134,7 @@ TEST(StanMathOde_ode_rk45_tol, ts) {
   EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
 }
 
-TEST(StanMathOde_ode_rk45_tol, ts_repeat) {
+TEST(StanMathOde_ode_rk45, ts_repeat) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -152,8 +144,8 @@ TEST(StanMathOde_ode_rk45_tol, ts_repeat) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+      = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                nullptr, a);
 
   output[0][0].grad();
 
@@ -182,7 +174,7 @@ TEST(StanMathOde_ode_rk45_tol, ts_repeat) {
   EXPECT_FLOAT_EQ(ts[3].adj(), -0.0791208888);
 }
 
-TEST(StanMathOde_ode_rk45_tol, scalar_arg) {
+TEST(StanMathOde_ode_rk45, scalar_arg) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -191,8 +183,8 @@ TEST(StanMathOde_ode_rk45_tol, scalar_arg) {
 
   var a = 1.5;
 
-  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0](0);
+  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -200,7 +192,33 @@ TEST(StanMathOde_ode_rk45_tol, scalar_arg) {
   EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_rk45_tol, std_vector_arg) {
+TEST(StanMathOde_ode_rk45, scalar_arg_multi_time) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  var a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                nullptr, a);
+
+  output[0](0).grad();
+
+  EXPECT_FLOAT_EQ(output[0](0).val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(a.adj(), -0.04352005542);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1](0).grad();
+
+  EXPECT_FLOAT_EQ(output[1](0).val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45, std_vector_arg) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -209,8 +227,8 @@ TEST(StanMathOde_ode_rk45_tol, std_vector_arg) {
 
   std::vector<var> a = {1.5};
 
-  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0](0);
+  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -218,7 +236,7 @@ TEST(StanMathOde_ode_rk45_tol, std_vector_arg) {
   EXPECT_FLOAT_EQ(a[0].adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_rk45_tol, vector_arg) {
+TEST(StanMathOde_ode_rk45, vector_arg) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -228,8 +246,8 @@ TEST(StanMathOde_ode_rk45_tol, vector_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0](0);
+  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -237,7 +255,7 @@ TEST(StanMathOde_ode_rk45_tol, vector_arg) {
   EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_rk45_tol, row_vector_arg) {
+TEST(StanMathOde_ode_rk45, row_vector_arg) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -247,8 +265,8 @@ TEST(StanMathOde_ode_rk45_tol, row_vector_arg) {
   Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0](0);
+  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -256,7 +274,7 @@ TEST(StanMathOde_ode_rk45_tol, row_vector_arg) {
   EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_rk45_tol, matrix_arg) {
+TEST(StanMathOde_ode_rk45, matrix_arg) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
@@ -266,8 +284,8 @@ TEST(StanMathOde_ode_rk45_tol, matrix_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
   a << 1.5;
 
-  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0](0);
+  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -275,24 +293,26 @@ TEST(StanMathOde_ode_rk45_tol, matrix_arg) {
   EXPECT_FLOAT_EQ(a(0, 0).adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_rk45_tol, scalar_std_vector_args) {
+TEST(StanMathOde_ode_rk45, scalar_std_vector_args) {
   using stan::math::var;
 
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0.0;
   std::vector<double> ts = {1.1};
 
-  var a0 = 0.0;
-  std::vector<var> a1 = {1.5};
+  var a0 = 0.75;
+  std::vector<var> a1 = {0.75};
 
-  var output = stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a0, a1)[0](0);
+  var output = stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
+                                       nullptr, a0, a1)[0][0];
 
   output.grad();
 
   EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a0.adj(), -0.50107310888);
   EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
 }
+
 struct ayt {
   template <typename T0, typename T1, typename T2>
   inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1>
@@ -302,7 +322,7 @@ struct ayt {
   }
 };
 
-TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
+TEST(StanMathOde_ode_rk45, arg_combos_test) {
   var t0 = 0.5;
   var a = 0.2;
   std::vector<var> ts = {1.25};
@@ -342,57 +362,57 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
                     exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
-  double yT1 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                        nullptr, ad)[0](0);
+  double yT1 = stan::math::ode_rk45(ayt(), y0d, t0d, tsd,
+                                       nullptr, ad)[0](0);
   check_yT(yT1);
 
-  var yT2 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+  var yT2 = stan::math::ode_rk45(ayt(), y0d, t0d, tsd,
+                                    nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
-  var yT3 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+  var yT3 = stan::math::ode_rk45(ayt(), y0d, t0d, ts,
+                                    nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
-  var yT4 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+  var yT4 = stan::math::ode_rk45(ayt(), y0d, t0d, ts,
+                                    nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
   check_ts(ts);
   check_a(a);
 
-  var yT5 = stan::math::ode_rk45_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+  var yT5 = stan::math::ode_rk45(ayt(), y0d, t0, tsd,
+                                    nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
-  var yT6 = stan::math::ode_rk45_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+  var yT6 = stan::math::ode_rk45(ayt(), y0d, t0, tsd,
+                                    nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
   check_t0(t0);
   check_a(a);
 
-  var yT7 = stan::math::ode_rk45_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+  var yT7 = stan::math::ode_rk45(ayt(), y0d, t0, ts,
+                                    nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
   check_t0(t0);
   check_ts(ts);
 
-  var yT8 = stan::math::ode_rk45_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+  var yT8 = stan::math::ode_rk45(ayt(), y0d, t0, ts,
+                                    nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -400,31 +420,31 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT9 = stan::math::ode_rk45_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+  var yT9 = stan::math::ode_rk45(ayt(), y0, t0d, tsd,
+                                    nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
-  var yT10 = stan::math::ode_rk45_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
+  var yT10 = stan::math::ode_rk45(ayt(), y0, t0d, tsd,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
   check_y0(y0);
   check_a(a);
 
-  var yT11 = stan::math::ode_rk45_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
+  var yT11 = stan::math::ode_rk45(ayt(), y0, t0d, ts,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
   check_y0(y0);
   check_ts(ts);
 
-  var yT12 = stan::math::ode_rk45_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
+  var yT12 = stan::math::ode_rk45(ayt(), y0, t0d, ts,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -432,16 +452,16 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT13 = stan::math::ode_rk45_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
+  var yT13 = stan::math::ode_rk45(ayt(), y0, t0, tsd,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
   check_y0(y0);
   check_t0(t0);
 
-  var yT14 = stan::math::ode_rk45_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
+  var yT14 = stan::math::ode_rk45(ayt(), y0, t0, tsd,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -449,8 +469,8 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   check_t0(t0);
   check_a(a);
 
-  var yT15 = stan::math::ode_rk45_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
+  var yT15 = stan::math::ode_rk45(ayt(), y0, t0, ts,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -458,8 +478,8 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   check_t0(t0);
   check_ts(ts);
 
-  var yT16 = stan::math::ode_rk45_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
+  var yT16 = stan::math::ode_rk45(ayt(), y0, t0, ts,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
diff --git a/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
new file mode 100644
index 00000000000..5fa95d3da80
--- /dev/null
+++ b/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
@@ -0,0 +1,490 @@
+#include <stan/math/rev.hpp>
+#include <gtest/gtest.h>
+#include <iostream>
+#include <vector>
+
+using stan::math::var;
+
+template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
+T sum_(T arg) {
+  return arg;
+}
+
+template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
+auto sum_(EigMat&& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
+auto sum_(Vec&& arg) {
+  stan::scalar_type_t<Vec> sum = 0;
+  for (size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
+  }
+  return sum;
+}
+
+struct CosArg1 {
+  template <typename T0, typename T1, typename... T_Args>
+  inline Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T_Args&... a) const {
+    std::vector<typename stan::return_type<T0, T_Args...>::type> vec
+        = {sum_(a)...};
+    Eigen::Matrix<stan::return_type_t<T1, T_Args...>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos(sum_(vec) * t);
+    return out;
+  }
+};
+
+struct Cos2Arg {
+  template <typename T0, typename T1, typename T2, typename T3>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a, const T3& b) const {
+    Eigen::Matrix<stan::return_type_t<T1, T2, T3>, Eigen::Dynamic, 1> out(1);
+    out << stan::math::cos((sum_(a) + sum_(b)) * t);
+    return out;
+  }
+};
+
+TEST(StanMathOde_ode_rk45_tol, int_t0) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  int t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
+      = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
+  EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
+}
+
+TEST(StanMathOde_ode_rk45_tol, int_ts) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<int> ts = {1, 2};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
+      = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
+  EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
+}
+
+TEST(StanMathOde_ode_rk45_tol, t0) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  var t0 = 0.0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+}
+
+TEST(StanMathOde_ode_rk45_tol, ts) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<var> ts = {0.45, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, ts_repeat) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<var> ts = {0.45, 0.45, 1.1, 1.1};
+
+  double a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0][0].grad();
+
+  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1][0].grad();
+
+  EXPECT_FLOAT_EQ(output[1][0].val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(ts[1].adj(), 0.78070695113);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[2][0].grad();
+
+  EXPECT_FLOAT_EQ(output[2][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[2].adj(), -0.0791208888);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[3][0].grad();
+
+  EXPECT_FLOAT_EQ(output[3][0].val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(ts[3].adj(), -0.0791208888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, scalar_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a = 1.5;
+
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, scalar_arg_multi_time) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  var a = 1.5;
+
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
+      = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                nullptr, a);
+
+  output[0](0).grad();
+
+  EXPECT_FLOAT_EQ(output[0](0).val(), 0.4165982112);
+  EXPECT_FLOAT_EQ(a.adj(), -0.04352005542);
+
+  stan::math::set_zero_all_adjoints();
+
+  output[1](0).grad();
+
+  EXPECT_FLOAT_EQ(output[1](0).val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, std_vector_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  std::vector<var> a = {1.5};
+
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a[0].adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, vector_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
+  a << 1.5;
+
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, row_vector_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
+  a << 1.5;
+
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, matrix_arg) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
+  a << 1.5;
+
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a(0, 0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, scalar_std_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 0.75;
+  std::vector<var> a1 = {0.75};
+
+  var output = stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a0, a1)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a0.adj(), -0.50107310888);
+  EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
+}
+
+struct ayt {
+  template <typename T0, typename T1, typename T2>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a) const {
+    return -a * y * t;
+  }
+};
+
+TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
+  var t0 = 0.5;
+  var a = 0.2;
+  std::vector<var> ts = {1.25};
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
+  y0 << 0.75;
+
+  double t0d = stan::math::value_of(t0);
+  double ad = stan::math::value_of(a);
+  std::vector<double> tsd = stan::math::value_of(ts);
+  Eigen::VectorXd y0d = stan::math::value_of(y0);
+
+  auto check_yT = [&](auto yT) {
+    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_t0 = [&](var t0) {
+    EXPECT_FLOAT_EQ(
+        t0.adj(),
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_a = [&](var a) {
+    EXPECT_FLOAT_EQ(a.adj(),
+                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_ts = [&](std::vector<var> ts) {
+    EXPECT_FLOAT_EQ(
+        ts[0].adj(),
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
+    EXPECT_FLOAT_EQ(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+  };
+
+  double yT1 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                       nullptr, ad)[0](0);
+  check_yT(yT1);
+
+  var yT2 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT2.grad();
+  check_yT(yT2);
+  check_a(a);
+
+  var yT3 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT3.grad();
+  check_yT(yT3);
+  check_ts(ts);
+
+  var yT4 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT4.grad();
+  check_yT(yT4);
+  check_ts(ts);
+  check_a(a);
+
+  var yT5 = stan::math::ode_rk45_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT5.grad();
+  check_yT(yT5);
+  check_t0(t0);
+
+  var yT6 = stan::math::ode_rk45_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT6.grad();
+  check_yT(yT6);
+  check_t0(t0);
+  check_a(a);
+
+  var yT7 = stan::math::ode_rk45_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT7.grad();
+  check_yT(yT7);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT8 = stan::math::ode_rk45_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                    nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT8.grad();
+  check_yT(yT8);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT9 = stan::math::ode_rk45_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                    nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT9.grad();
+  check_yT(yT9);
+  check_y0(y0);
+
+  var yT10 = stan::math::ode_rk45_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT10.grad();
+  check_yT(yT10);
+  check_y0(y0);
+  check_a(a);
+
+  var yT11 = stan::math::ode_rk45_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT11.grad();
+  check_yT(yT11);
+  check_y0(y0);
+  check_ts(ts);
+
+  var yT12 = stan::math::ode_rk45_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT12.grad();
+  check_yT(yT12);
+  check_y0(y0);
+  check_ts(ts);
+  check_a(a);
+
+  var yT13 = stan::math::ode_rk45_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT13.grad();
+  check_yT(yT13);
+  check_y0(y0);
+  check_t0(t0);
+
+  var yT14 = stan::math::ode_rk45_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT14.grad();
+  check_yT(yT14);
+  check_y0(y0);
+  check_t0(t0);
+  check_a(a);
+
+  var yT15 = stan::math::ode_rk45_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT15.grad();
+  check_yT(yT15);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+
+  var yT16 = stan::math::ode_rk45_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
+  stan::math::set_zero_all_adjoints();
+  yT16.grad();
+  check_yT(yT16);
+  check_y0(y0);
+  check_t0(t0);
+  check_ts(ts);
+  check_a(a);
+}

From 0eb138274b1b2750fe870346418515b0cb85dda2 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 1 Jun 2020 19:51:16 +0000
Subject: [PATCH 133/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

---
 stan/math/prim/functor/ode_rk45.hpp           |   8 +-
 .../math/prim/functor/ode_rk45_prim_test.cpp  |  75 ++++-----
 .../prim/functor/ode_rk45_tol_prim_test.cpp   | 114 +++++++-------
 .../math/rev/functor/ode_adams_prim_test.cpp  |  75 ++++-----
 .../math/rev/functor/ode_adams_rev_test.cpp   |  85 ++++------
 .../rev/functor/ode_adams_tol_prim_test.cpp   | 116 +++++++-------
 .../rev/functor/ode_adams_tol_rev_test.cpp    | 146 +++++++++---------
 .../math/rev/functor/ode_bdf_prim_test.cpp    |  75 ++++-----
 .../math/rev/functor/ode_bdf_rev_test.cpp     |  85 ++++------
 .../math/rev/functor/ode_rk45_rev_test.cpp    |  85 ++++------
 .../rev/functor/ode_rk45_tol_rev_test.cpp     |  56 +++----
 11 files changed, 389 insertions(+), 531 deletions(-)

diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index e8f53f74394..9ceb84d8d9d 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -65,7 +65,7 @@ ode_rk45_tol(const F& f,
   using boost::numeric::odeint::vector_space_algebra;
 
   using T_initial_or_t0 = return_type_t<T_initial, T_t0>;
-  
+
   Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1> y0 = y0_arg.unaryExpr(
       [](const T_initial& val) { return T_initial_or_t0(val); });
 
@@ -83,8 +83,10 @@ ode_rk45_tol(const F& f,
   check_sorted("integrate_ode_rk45", "times", ts);
   check_less("integrate_ode_rk45", "initial time", t0, ts[0]);
 
-  check_positive_finite("integrate_ode_rk45", "relative_tolerance", relative_tolerance);
-  check_positive_finite("integrate_ode_rk45", "absolute_tolerance", absolute_tolerance);
+  check_positive_finite("integrate_ode_rk45", "relative_tolerance",
+                        relative_tolerance);
+  check_positive_finite("integrate_ode_rk45", "absolute_tolerance",
+                        absolute_tolerance);
   check_positive("integrate_ode_rk45", "max_num_steps", max_num_steps);
 
   using return_t = return_type_t<T_initial, T_t0, T_ts, Args...>;
diff --git a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
index 43c8ea822be..4fa3afb0438 100644
--- a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
@@ -116,26 +116,23 @@ TEST(ode_rk45_prim, ts_errors) {
 
   EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a));
 
-  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts_repeat, nullptr, a));
+  EXPECT_NO_THROW(
+      stan::math::ode_rk45(CosArg1(), y0, t0, ts_repeat, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts_empty,
-				   nullptr, a),
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts_empty, nullptr, a),
                std::invalid_argument);
 
-  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts_early,
-				   nullptr, a),
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts_early, nullptr, a),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts_decreasing,
-				   nullptr, a),
-               std::domain_error);
+  EXPECT_THROW(
+      stan::math::ode_rk45(CosArg1(), y0, t0, ts_decreasing, nullptr, a),
+      std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, tsinf,
-				   nullptr, a),
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, tsinf, nullptr, a),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, tsNaN,
-				   nullptr, a),
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, tsNaN, nullptr, a),
                std::domain_error);
 }
 
@@ -159,37 +156,28 @@ TEST(ode_rk45_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-				      nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                       nullptr, ainf),
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, ainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                       nullptr, aNaN),
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, aNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-				      nullptr, va));
+  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, va));
 
-  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                       nullptr, vainf),
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, vainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                       nullptr, vaNaN),
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, vaNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-				      nullptr, ea));
+  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, ea));
 
-  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                       nullptr, eainf),
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, eainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                       nullptr, eaNaN),
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, eaNaN),
                std::domain_error);
 }
 
@@ -213,37 +201,28 @@ TEST(ode_rk45_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  EXPECT_NO_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
-				      nullptr, a, a));
+  EXPECT_NO_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, a));
 
-  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, ainf),
+  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, ainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, aNaN),
+  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, aNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
-				      nullptr, a, va));
+  EXPECT_NO_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, va));
 
-  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, vainf),
+  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, vainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, vaNaN),
+  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, vaNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
-				      nullptr, a, ea));
+  EXPECT_NO_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, ea));
 
-  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, eainf),
+  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, eainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, eaNaN),
+  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, eaNaN),
                std::domain_error);
 }
 
diff --git a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
index 09b63d497d3..8a4af680083 100644
--- a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
@@ -72,18 +72,18 @@ TEST(ode_rk45_tol_prim, y0_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+                                           1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0inf, t0, ts, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0NaN, t0, ts, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0_empty, t0, ts, 1e-10,
-                                       1e-10, 1e6, nullptr, a),
+                                        1e-10, 1e6, nullptr, a),
                std::invalid_argument);
 }
 
@@ -97,14 +97,14 @@ TEST(ode_rk45_tol_prim, t0_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+                                           1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0inf, ts, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0NaN, ts, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -122,29 +122,29 @@ TEST(ode_rk45_tol_prim, ts_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+                                           1e6, nullptr, a));
 
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
-                                          1e-10, 1e6, nullptr, a));
+                                           1e-10, 1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
-                                       1e-10, 1e6, nullptr, a),
+                                        1e-10, 1e6, nullptr, a),
                std::invalid_argument);
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_early, 1e-10,
-                                       1e-10, 1e6, nullptr, a),
+                                        1e-10, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_decreasing, 1e-10,
-                                       1e-10, 1e6, nullptr, a),
+                                        1e-10, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, tsinf, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, tsNaN, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -169,36 +169,36 @@ TEST(ode_rk45_tol_prim, one_arg_errors) {
   eaNaN << aNaN;
 
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+                                           1e6, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, ainf),
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, ainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, aNaN),
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, aNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, va));
+                                           1e6, nullptr, va));
 
-  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, vainf),
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, vainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, vaNaN),
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, vaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, ea));
+                                           1e6, nullptr, ea));
 
-  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, eainf),
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, eainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, eaNaN),
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, eaNaN),
                std::domain_error);
 }
 
@@ -223,36 +223,36 @@ TEST(ode_rk45_tol_prim, two_arg_errors) {
   eaNaN << aNaN;
 
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a, a));
+                                           1e6, nullptr, a, a));
 
-  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, ainf),
+  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, ainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, aNaN),
+  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, aNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a, va));
+                                           1e6, nullptr, a, va));
 
-  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, vainf),
+  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, vainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, vaNaN),
+  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, vaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a, ea));
+                                           1e6, nullptr, a, ea));
 
-  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, eainf),
+  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, eainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, eaNaN),
+  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, eaNaN),
                std::domain_error);
 }
 
@@ -269,18 +269,18 @@ TEST(ode_rk45_tol_prim, rtol_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, rtol, 1e-10,
-                                          1e6, nullptr, a));
+                                           1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, rtol_negative,
-                                       1e-10, 1e6, nullptr, a),
+                                        1e-10, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, rtolinf, 1e-10,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, rtolNaN, 1e-10,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -297,18 +297,18 @@ TEST(ode_rk45_tol_prim, atol_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, atol,
-                                          1e6, nullptr, a));
+                                           1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6,
-                                       atol_negative, 1e6, nullptr, a),
+                                        atol_negative, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, atolinf,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, atolNaN,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -324,14 +324,14 @@ TEST(ode_rk45_tol_prim, max_num_steps_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                          max_num_steps, nullptr, a));
+                                           max_num_steps, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                       max_num_steps_negative, nullptr, a),
+                                        max_num_steps_negative, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                       max_num_steps_zero, nullptr, a),
+                                        max_num_steps_zero, nullptr, a),
                std::domain_error);
 }
 
@@ -343,9 +343,9 @@ TEST(ode_rk45_tol_prim, rhs_wrong_size_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                          100, nullptr, a));
+                                           100, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArgWrongSize(), y0, t0, ts, 1e-6,
-                                       1e-6, 100, nullptr, a),
+                                        1e-6, 100, nullptr, a),
                std::invalid_argument);
 }
diff --git a/test/unit/math/rev/functor/ode_adams_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
index 52b664f5a2b..5d545b8d3cd 100644
--- a/test/unit/math/rev/functor/ode_adams_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
@@ -116,26 +116,23 @@ TEST(ode_adams_prim, ts_errors) {
 
   EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a));
 
-  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts_repeat, nullptr, a));
+  EXPECT_NO_THROW(
+      stan::math::ode_adams(CosArg1(), y0, t0, ts_repeat, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts_empty,
-				   nullptr, a),
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts_empty, nullptr, a),
                std::invalid_argument);
 
-  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts_early,
-				   nullptr, a),
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts_early, nullptr, a),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts_decreasing,
-				   nullptr, a),
-               std::domain_error);
+  EXPECT_THROW(
+      stan::math::ode_adams(CosArg1(), y0, t0, ts_decreasing, nullptr, a),
+      std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, tsinf,
-				   nullptr, a),
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, tsinf, nullptr, a),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, tsNaN,
-				   nullptr, a),
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, tsNaN, nullptr, a),
                std::domain_error);
 }
 
@@ -159,37 +156,28 @@ TEST(ode_adams_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
-				      nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                       nullptr, ainf),
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, ainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                       nullptr, aNaN),
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, aNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
-				      nullptr, va));
+  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, va));
 
-  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                       nullptr, vainf),
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, vainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                       nullptr, vaNaN),
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, vaNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
-				      nullptr, ea));
+  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, ea));
 
-  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                       nullptr, eainf),
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, eainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                       nullptr, eaNaN),
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, eaNaN),
                std::domain_error);
 }
 
@@ -213,37 +201,28 @@ TEST(ode_adams_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  EXPECT_NO_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
-				      nullptr, a, a));
+  EXPECT_NO_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, a));
 
-  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, ainf),
+  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, ainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, aNaN),
+  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, aNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
-				      nullptr, a, va));
+  EXPECT_NO_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, va));
 
-  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, vainf),
+  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, vainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, vaNaN),
+  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, vaNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
-				      nullptr, a, ea));
+  EXPECT_NO_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, ea));
 
-  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, eainf),
+  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, eainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, eaNaN),
+  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, eaNaN),
                std::domain_error);
 }
 
diff --git a/test/unit/math/rev/functor/ode_adams_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
index 0893187c55a..783c3b23911 100644
--- a/test/unit/math/rev/functor/ode_adams_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
@@ -58,8 +58,7 @@ TEST(StanMathOde_ode_adams, int_t0) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
-      = stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
   EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
@@ -75,8 +74,7 @@ TEST(StanMathOde_ode_adams, int_ts) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
-      = stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
   EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
@@ -92,8 +90,7 @@ TEST(StanMathOde_ode_adams, t0) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a);
 
   output[0][0].grad();
 
@@ -118,8 +115,7 @@ TEST(StanMathOde_ode_adams, ts) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a);
 
   output[0][0].grad();
 
@@ -144,8 +140,7 @@ TEST(StanMathOde_ode_adams, ts_repeat) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a);
 
   output[0][0].grad();
 
@@ -183,8 +178,7 @@ TEST(StanMathOde_ode_adams, scalar_arg) {
 
   var a = 1.5;
 
-  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a)[0][0];
 
   output.grad();
 
@@ -202,8 +196,7 @@ TEST(StanMathOde_ode_adams, scalar_arg_multi_time) {
   var a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a);
 
   output[0](0).grad();
 
@@ -227,8 +220,7 @@ TEST(StanMathOde_ode_adams, std_vector_arg) {
 
   std::vector<var> a = {1.5};
 
-  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a)[0][0];
 
   output.grad();
 
@@ -246,8 +238,7 @@ TEST(StanMathOde_ode_adams, vector_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a)[0][0];
 
   output.grad();
 
@@ -265,8 +256,7 @@ TEST(StanMathOde_ode_adams, row_vector_arg) {
   Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a)[0][0];
 
   output.grad();
 
@@ -284,8 +274,7 @@ TEST(StanMathOde_ode_adams, matrix_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
   a << 1.5;
 
-  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a)[0][0];
 
   output.grad();
 
@@ -303,8 +292,8 @@ TEST(StanMathOde_ode_adams, scalar_std_vector_args) {
   var a0 = 0.75;
   std::vector<var> a1 = {0.75};
 
-  var output = stan::math::ode_adams(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a0, a1)[0][0];
+  var output
+      = stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a0, a1)[0][0];
 
   output.grad();
 
@@ -362,57 +351,49 @@ TEST(StanMathOde_ode_adams, arg_combos_test) {
                     exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
-  double yT1 = stan::math::ode_adams(ayt(), y0d, t0d, tsd,
-                                       nullptr, ad)[0](0);
+  double yT1 = stan::math::ode_adams(ayt(), y0d, t0d, tsd, nullptr, ad)[0](0);
   check_yT(yT1);
 
-  var yT2 = stan::math::ode_adams(ayt(), y0d, t0d, tsd,
-                                    nullptr, a)[0](0);
+  var yT2 = stan::math::ode_adams(ayt(), y0d, t0d, tsd, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
-  var yT3 = stan::math::ode_adams(ayt(), y0d, t0d, ts,
-                                    nullptr, ad)[0](0);
+  var yT3 = stan::math::ode_adams(ayt(), y0d, t0d, ts, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
-  var yT4 = stan::math::ode_adams(ayt(), y0d, t0d, ts,
-                                    nullptr, a)[0](0);
+  var yT4 = stan::math::ode_adams(ayt(), y0d, t0d, ts, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
   check_ts(ts);
   check_a(a);
 
-  var yT5 = stan::math::ode_adams(ayt(), y0d, t0, tsd,
-                                    nullptr, ad)[0](0);
+  var yT5 = stan::math::ode_adams(ayt(), y0d, t0, tsd, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
-  var yT6 = stan::math::ode_adams(ayt(), y0d, t0, tsd,
-                                    nullptr, a)[0](0);
+  var yT6 = stan::math::ode_adams(ayt(), y0d, t0, tsd, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
   check_t0(t0);
   check_a(a);
 
-  var yT7 = stan::math::ode_adams(ayt(), y0d, t0, ts,
-                                    nullptr, ad)[0](0);
+  var yT7 = stan::math::ode_adams(ayt(), y0d, t0, ts, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
   check_t0(t0);
   check_ts(ts);
 
-  var yT8 = stan::math::ode_adams(ayt(), y0d, t0, ts,
-                                    nullptr, a)[0](0);
+  var yT8 = stan::math::ode_adams(ayt(), y0d, t0, ts, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -420,31 +401,27 @@ TEST(StanMathOde_ode_adams, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT9 = stan::math::ode_adams(ayt(), y0, t0d, tsd,
-                                    nullptr, ad)[0](0);
+  var yT9 = stan::math::ode_adams(ayt(), y0, t0d, tsd, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
-  var yT10 = stan::math::ode_adams(ayt(), y0, t0d, tsd,
-                                     nullptr, a)[0](0);
+  var yT10 = stan::math::ode_adams(ayt(), y0, t0d, tsd, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
   check_y0(y0);
   check_a(a);
 
-  var yT11 = stan::math::ode_adams(ayt(), y0, t0d, ts,
-                                     nullptr, ad)[0](0);
+  var yT11 = stan::math::ode_adams(ayt(), y0, t0d, ts, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
   check_y0(y0);
   check_ts(ts);
 
-  var yT12 = stan::math::ode_adams(ayt(), y0, t0d, ts,
-                                     nullptr, a)[0](0);
+  var yT12 = stan::math::ode_adams(ayt(), y0, t0d, ts, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -452,16 +429,14 @@ TEST(StanMathOde_ode_adams, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT13 = stan::math::ode_adams(ayt(), y0, t0, tsd,
-                                     nullptr, ad)[0](0);
+  var yT13 = stan::math::ode_adams(ayt(), y0, t0, tsd, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
   check_y0(y0);
   check_t0(t0);
 
-  var yT14 = stan::math::ode_adams(ayt(), y0, t0, tsd,
-                                     nullptr, a)[0](0);
+  var yT14 = stan::math::ode_adams(ayt(), y0, t0, tsd, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -469,8 +444,7 @@ TEST(StanMathOde_ode_adams, arg_combos_test) {
   check_t0(t0);
   check_a(a);
 
-  var yT15 = stan::math::ode_adams(ayt(), y0, t0, ts,
-                                     nullptr, ad)[0](0);
+  var yT15 = stan::math::ode_adams(ayt(), y0, t0, ts, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -478,8 +452,7 @@ TEST(StanMathOde_ode_adams, arg_combos_test) {
   check_t0(t0);
   check_ts(ts);
 
-  var yT16 = stan::math::ode_adams(ayt(), y0, t0, ts,
-                                     nullptr, a)[0](0);
+  var yT16 = stan::math::ode_adams(ayt(), y0, t0, ts, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
diff --git a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
index 6a9188e016f..ac53cc574ed 100644
--- a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
@@ -72,18 +72,18 @@ TEST(ode_adams_tol_prim, y0_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+                                            1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0inf, t0, ts, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0NaN, t0, ts, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0_empty, t0, ts, 1e-10,
-                                       1e-10, 1e6, nullptr, a),
+                                         1e-10, 1e6, nullptr, a),
                std::invalid_argument);
 }
 
@@ -97,14 +97,14 @@ TEST(ode_adams_tol_prim, t0_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+                                            1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0inf, ts, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0NaN, ts, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -122,29 +122,29 @@ TEST(ode_adams_tol_prim, ts_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+                                            1e6, nullptr, a));
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
-                                          1e-10, 1e6, nullptr, a));
+                                            1e-10, 1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
-                                       1e-10, 1e6, nullptr, a),
+                                         1e-10, 1e6, nullptr, a),
                std::invalid_argument);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_early, 1e-10,
-                                       1e-10, 1e6, nullptr, a),
+                                         1e-10, 1e6, nullptr, a),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_decreasing, 1e-10,
-                                       1e-10, 1e6, nullptr, a),
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_decreasing,
+                                         1e-10, 1e-10, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, tsinf, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, tsNaN, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -169,36 +169,36 @@ TEST(ode_adams_tol_prim, one_arg_errors) {
   eaNaN << aNaN;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+                                            1e6, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, ainf),
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                         1e6, nullptr, ainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, aNaN),
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                         1e6, nullptr, aNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, va));
+                                            1e6, nullptr, va));
 
-  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, vainf),
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                         1e6, nullptr, vainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, vaNaN),
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                         1e6, nullptr, vaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, ea));
+                                            1e6, nullptr, ea));
 
-  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, eainf),
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                         1e6, nullptr, eainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, eaNaN),
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                         1e6, nullptr, eaNaN),
                std::domain_error);
 }
 
@@ -223,36 +223,36 @@ TEST(ode_adams_tol_prim, two_arg_errors) {
   eaNaN << aNaN;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a, a));
+                                            1e6, nullptr, a, a));
 
-  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, ainf),
+  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                         1e6, nullptr, a, ainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, aNaN),
+  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                         1e6, nullptr, a, aNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a, va));
+                                            1e6, nullptr, a, va));
 
-  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, vainf),
+  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                         1e6, nullptr, a, vainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, vaNaN),
+  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                         1e6, nullptr, a, vaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a, ea));
+                                            1e6, nullptr, a, ea));
 
-  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, eainf),
+  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                         1e6, nullptr, a, eainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, eaNaN),
+  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                         1e6, nullptr, a, eaNaN),
                std::domain_error);
 }
 
@@ -269,18 +269,18 @@ TEST(ode_adams_tol_prim, rtol_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, rtol, 1e-10,
-                                          1e6, nullptr, a));
+                                            1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, rtol_negative,
-                                       1e-10, 1e6, nullptr, a),
+                                         1e-10, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, rtolinf, 1e-10,
-                                       1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, rtolNaN, 1e-10,
-                                       1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -297,18 +297,18 @@ TEST(ode_adams_tol_prim, atol_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, atol,
-                                          1e6, nullptr, a));
+                                            1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6,
-                                       atol_negative, 1e6, nullptr, a),
+                                         atol_negative, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, atolinf,
-                                       1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, atolNaN,
-                                       1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -324,14 +324,14 @@ TEST(ode_adams_tol_prim, max_num_steps_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                          max_num_steps, nullptr, a));
+                                            max_num_steps, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                       max_num_steps_negative, nullptr, a),
+                                         max_num_steps_negative, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                       max_num_steps_zero, nullptr, a),
+                                         max_num_steps_zero, nullptr, a),
                std::domain_error);
 }
 
@@ -343,9 +343,9 @@ TEST(ode_adams_tol_prim, rhs_wrong_size_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                          100, nullptr, a));
+                                            100, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArgWrongSize(), y0, t0, ts, 1e-6,
-                                       1e-6, 100, nullptr, a),
+                                         1e-6, 100, nullptr, a),
                std::invalid_argument);
 }
diff --git a/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
index f440b41ea29..5c9693e1ada 100644
--- a/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
@@ -59,7 +59,7 @@ TEST(StanMathOde_ode_adams_tol, int_t0) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                  nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
   EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
@@ -76,7 +76,7 @@ TEST(StanMathOde_ode_adams_tol, int_ts) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                  nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
   EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
@@ -93,7 +93,7 @@ TEST(StanMathOde_ode_adams_tol, t0) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                  nullptr, a);
 
   output[0][0].grad();
 
@@ -119,7 +119,7 @@ TEST(StanMathOde_ode_adams_tol, ts) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                  nullptr, a);
 
   output[0][0].grad();
 
@@ -145,7 +145,7 @@ TEST(StanMathOde_ode_adams_tol, ts_repeat) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                  nullptr, a);
 
   output[0][0].grad();
 
@@ -183,8 +183,8 @@ TEST(StanMathOde_ode_adams_tol, scalar_arg) {
 
   var a = 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -203,7 +203,7 @@ TEST(StanMathOde_ode_adams_tol, scalar_arg_multi_time) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                  nullptr, a);
 
   output[0](0).grad();
 
@@ -227,8 +227,8 @@ TEST(StanMathOde_ode_adams_tol, std_vector_arg) {
 
   std::vector<var> a = {1.5};
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -246,8 +246,8 @@ TEST(StanMathOde_ode_adams_tol, vector_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -265,8 +265,8 @@ TEST(StanMathOde_ode_adams_tol, row_vector_arg) {
   Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -284,8 +284,8 @@ TEST(StanMathOde_ode_adams_tol, matrix_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
   a << 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -303,8 +303,8 @@ TEST(StanMathOde_ode_adams_tol, scalar_std_vector_args) {
   var a0 = 0.75;
   std::vector<var> a1 = {0.75};
 
-  var output = stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a0, a1)[0][0];
+  var output = stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a0, a1)[0][0];
 
   output.grad();
 
@@ -362,26 +362,26 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
                     exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
-  double yT1 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                       nullptr, ad)[0](0);
+  double yT1 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                         1e6, nullptr, ad)[0](0);
   check_yT(yT1);
 
   var yT2 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
   var yT3 = stan::math::ode_adams_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
   var yT4 = stan::math::ode_adams_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
@@ -389,14 +389,14 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT5 = stan::math::ode_adams_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
   var yT6 = stan::math::ode_adams_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
@@ -404,7 +404,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT7 = stan::math::ode_adams_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
@@ -412,7 +412,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_ts(ts);
 
   var yT8 = stan::math::ode_adams_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -421,14 +421,14 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT9 = stan::math::ode_adams_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
   var yT10 = stan::math::ode_adams_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                       nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
@@ -436,7 +436,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT11 = stan::math::ode_adams_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                       nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
@@ -444,7 +444,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_ts(ts);
 
   var yT12 = stan::math::ode_adams_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                       nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -453,7 +453,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT13 = stan::math::ode_adams_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                       nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
@@ -461,7 +461,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_t0(t0);
 
   var yT14 = stan::math::ode_adams_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                       nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -470,7 +470,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT15 = stan::math::ode_adams_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                       nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -479,7 +479,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_ts(ts);
 
   var yT16 = stan::math::ode_adams_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                       nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
@@ -529,26 +529,26 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
                     exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
-  double yT1 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                             1e6, nullptr, ad)[0](0);
+  double yT1 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, tsd, 1e-10,
+                                               1e-10, 1e6, nullptr, ad)[0](0);
   check_yT(yT1);
 
   var yT2 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                          1e6, nullptr, a)[0](0);
+                                            1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
   var yT3 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, ad)[0](0);
+                                            1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
   var yT4 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a)[0](0);
+                                            1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
@@ -556,30 +556,30 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
   check_a(a);
 
   var yT5 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
-                                          1e6, nullptr, ad)[0](0);
+                                            1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
   var yT6 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
-                                          1e6, nullptr, a)[0](0);
+                                            1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
   check_t0(t0);
   check_a(a);
 
-  var yT7 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                          nullptr, ad)[0](0);
+  var yT7 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10,
+                                            1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
   check_t0(t0);
   check_ts(ts);
 
-  var yT8 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                          nullptr, a)[0](0);
+  var yT8 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10,
+                                            1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -588,14 +588,14 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
   check_a(a);
 
   var yT9 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
-                                          1e6, nullptr, ad)[0](0);
+                                            1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
   var yT10 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
-                                           1e6, nullptr, a)[0](0);
+                                             1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
@@ -603,7 +603,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
   check_a(a);
 
   var yT11 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, ad)[0](0);
+                                             1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
@@ -611,7 +611,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
   check_ts(ts);
 
   var yT12 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a)[0](0);
+                                             1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -620,7 +620,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
   check_a(a);
 
   var yT13 = stan::math::ode_adams_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
-                                           1e6, nullptr, ad)[0](0);
+                                             1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
@@ -628,7 +628,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
   check_t0(t0);
 
   var yT14 = stan::math::ode_adams_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
-                                           1e6, nullptr, a)[0](0);
+                                             1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -636,8 +636,8 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
   check_t0(t0);
   check_a(a);
 
-  var yT15 = stan::math::ode_adams_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                           nullptr, ad)[0](0);
+  var yT15 = stan::math::ode_adams_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10,
+                                             1e6, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -645,8 +645,8 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
   check_t0(t0);
   check_ts(ts);
 
-  var yT16 = stan::math::ode_adams_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                           nullptr, a)[0](0);
+  var yT16 = stan::math::ode_adams_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10,
+                                             1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
@@ -730,8 +730,8 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_t0(t0);
 
   var yT6 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10,
-                                               1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
-                                               nullptr, a)[0](0);
+                                                 1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
+                                                 nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
@@ -746,9 +746,9 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_t0(t0);
   check_ts(ts);
 
-  var yT8 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, ts, 1e-10, 1e-10,
-                                               1e-6, {1e-6, 1e-6}, 1e6, nullptr,
-                                               a)[0](0);
+  var yT8 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, ts, 1e-10,
+                                                 1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
+                                                 nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -764,8 +764,8 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_y0(y0);
 
   var yT10 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10,
-                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
-                                                nullptr, a)[0](0);
+                                                  1e-10, 1e-6, {1e-6, 1e-6},
+                                                  1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
@@ -781,8 +781,8 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_ts(ts);
 
   var yT12 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, ts, 1e-10,
-                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
-                                                nullptr, a)[0](0);
+                                                  1e-10, 1e-6, {1e-6, 1e-6},
+                                                  1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -799,8 +799,8 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_t0(t0);
 
   var yT14 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, tsd, 1e-10,
-                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
-                                                nullptr, a)[0](0);
+                                                  1e-10, 1e-6, {1e-6, 1e-6},
+                                                  1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -817,9 +817,9 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_t0(t0);
   check_ts(ts);
 
-  var yT16 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, ts, 1e-10, 1e-10,
-                                                1e-6, {1e-6, 1e-6}, 1e6,
-                                                nullptr, a)[0](0);
+  var yT16 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, ts, 1e-10,
+                                                  1e-10, 1e-6, {1e-6, 1e-6},
+                                                  1e6, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
@@ -830,16 +830,16 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
 
   EXPECT_THROW(
       stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                         1e-6, {1e-6, 1e-6}, 1e6, nullptr, a),
+                                           1e-6, {1e-6, 1e-6}, 1e6, nullptr, a),
       std::invalid_argument);
 
   EXPECT_THROW(
       stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                         -1e-6, {1e-6}, 1e6, nullptr, a),
+                                           -1e-6, {1e-6}, 1e6, nullptr, a),
       std::domain_error);
 
   EXPECT_THROW(
       stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                         -1e-6, {-1e-6}, 1e6, nullptr, a),
+                                           -1e-6, {-1e-6}, 1e6, nullptr, a),
       std::domain_error);
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index 74dca59d4be..38407be8aca 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -116,26 +116,23 @@ TEST(ode_bdf_prim, ts_errors) {
 
   EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a));
 
-  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts_repeat, nullptr, a));
+  EXPECT_NO_THROW(
+      stan::math::ode_bdf(CosArg1(), y0, t0, ts_repeat, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts_empty,
-				   nullptr, a),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts_empty, nullptr, a),
                std::invalid_argument);
 
-  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts_early,
-				   nullptr, a),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts_early, nullptr, a),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts_decreasing,
-				   nullptr, a),
-               std::domain_error);
+  EXPECT_THROW(
+      stan::math::ode_bdf(CosArg1(), y0, t0, ts_decreasing, nullptr, a),
+      std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, tsinf,
-				   nullptr, a),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, tsinf, nullptr, a),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, tsNaN,
-				   nullptr, a),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, tsNaN, nullptr, a),
                std::domain_error);
 }
 
@@ -159,37 +156,28 @@ TEST(ode_bdf_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-				      nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                       nullptr, ainf),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, ainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                       nullptr, aNaN),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, aNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-				      nullptr, va));
+  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, va));
 
-  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                       nullptr, vainf),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, vainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                       nullptr, vaNaN),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, vaNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-				      nullptr, ea));
+  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, ea));
 
-  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                       nullptr, eainf),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, eainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                       nullptr, eaNaN),
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, eaNaN),
                std::domain_error);
 }
 
@@ -213,37 +201,28 @@ TEST(ode_bdf_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
-				      nullptr, a, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, a));
 
-  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, ainf),
+  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, ainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, aNaN),
+  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, aNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
-				      nullptr, a, va));
+  EXPECT_NO_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, va));
 
-  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, vainf),
+  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, vainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, vaNaN),
+  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, vaNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
-				      nullptr, a, ea));
+  EXPECT_NO_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, ea));
 
-  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, eainf),
+  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, eainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a, eaNaN),
+  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, eaNaN),
                std::domain_error);
 }
 
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index b0505cc9723..4f48c81fd7e 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -58,8 +58,7 @@ TEST(StanMathOde_ode_bdf, int_t0) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
-      = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
   EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
@@ -75,8 +74,7 @@ TEST(StanMathOde_ode_bdf, int_ts) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
-      = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
   EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
@@ -92,8 +90,7 @@ TEST(StanMathOde_ode_bdf, t0) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a);
 
   output[0][0].grad();
 
@@ -118,8 +115,7 @@ TEST(StanMathOde_ode_bdf, ts) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a);
 
   output[0][0].grad();
 
@@ -144,8 +140,7 @@ TEST(StanMathOde_ode_bdf, ts_repeat) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a);
 
   output[0][0].grad();
 
@@ -183,8 +178,7 @@ TEST(StanMathOde_ode_bdf, scalar_arg) {
 
   var a = 1.5;
 
-  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a)[0][0];
 
   output.grad();
 
@@ -202,8 +196,7 @@ TEST(StanMathOde_ode_bdf, scalar_arg_multi_time) {
   var a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a);
 
   output[0](0).grad();
 
@@ -227,8 +220,7 @@ TEST(StanMathOde_ode_bdf, std_vector_arg) {
 
   std::vector<var> a = {1.5};
 
-  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a)[0][0];
 
   output.grad();
 
@@ -246,8 +238,7 @@ TEST(StanMathOde_ode_bdf, vector_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a)[0][0];
 
   output.grad();
 
@@ -265,8 +256,7 @@ TEST(StanMathOde_ode_bdf, row_vector_arg) {
   Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a)[0][0];
 
   output.grad();
 
@@ -284,8 +274,7 @@ TEST(StanMathOde_ode_bdf, matrix_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
   a << 1.5;
 
-  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a)[0][0];
 
   output.grad();
 
@@ -303,8 +292,8 @@ TEST(StanMathOde_ode_bdf, scalar_std_vector_args) {
   var a0 = 0.75;
   std::vector<var> a1 = {0.75};
 
-  var output = stan::math::ode_bdf(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a0, a1)[0][0];
+  var output
+      = stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a0, a1)[0][0];
 
   output.grad();
 
@@ -362,57 +351,49 @@ TEST(StanMathOde_ode_bdf, arg_combos_test) {
                     exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
-  double yT1 = stan::math::ode_bdf(ayt(), y0d, t0d, tsd,
-                                       nullptr, ad)[0](0);
+  double yT1 = stan::math::ode_bdf(ayt(), y0d, t0d, tsd, nullptr, ad)[0](0);
   check_yT(yT1);
 
-  var yT2 = stan::math::ode_bdf(ayt(), y0d, t0d, tsd,
-                                    nullptr, a)[0](0);
+  var yT2 = stan::math::ode_bdf(ayt(), y0d, t0d, tsd, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
-  var yT3 = stan::math::ode_bdf(ayt(), y0d, t0d, ts,
-                                    nullptr, ad)[0](0);
+  var yT3 = stan::math::ode_bdf(ayt(), y0d, t0d, ts, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
-  var yT4 = stan::math::ode_bdf(ayt(), y0d, t0d, ts,
-                                    nullptr, a)[0](0);
+  var yT4 = stan::math::ode_bdf(ayt(), y0d, t0d, ts, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
   check_ts(ts);
   check_a(a);
 
-  var yT5 = stan::math::ode_bdf(ayt(), y0d, t0, tsd,
-                                    nullptr, ad)[0](0);
+  var yT5 = stan::math::ode_bdf(ayt(), y0d, t0, tsd, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
-  var yT6 = stan::math::ode_bdf(ayt(), y0d, t0, tsd,
-                                    nullptr, a)[0](0);
+  var yT6 = stan::math::ode_bdf(ayt(), y0d, t0, tsd, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
   check_t0(t0);
   check_a(a);
 
-  var yT7 = stan::math::ode_bdf(ayt(), y0d, t0, ts,
-                                    nullptr, ad)[0](0);
+  var yT7 = stan::math::ode_bdf(ayt(), y0d, t0, ts, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
   check_t0(t0);
   check_ts(ts);
 
-  var yT8 = stan::math::ode_bdf(ayt(), y0d, t0, ts,
-                                    nullptr, a)[0](0);
+  var yT8 = stan::math::ode_bdf(ayt(), y0d, t0, ts, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -420,31 +401,27 @@ TEST(StanMathOde_ode_bdf, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT9 = stan::math::ode_bdf(ayt(), y0, t0d, tsd,
-                                    nullptr, ad)[0](0);
+  var yT9 = stan::math::ode_bdf(ayt(), y0, t0d, tsd, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
-  var yT10 = stan::math::ode_bdf(ayt(), y0, t0d, tsd,
-                                     nullptr, a)[0](0);
+  var yT10 = stan::math::ode_bdf(ayt(), y0, t0d, tsd, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
   check_y0(y0);
   check_a(a);
 
-  var yT11 = stan::math::ode_bdf(ayt(), y0, t0d, ts,
-                                     nullptr, ad)[0](0);
+  var yT11 = stan::math::ode_bdf(ayt(), y0, t0d, ts, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
   check_y0(y0);
   check_ts(ts);
 
-  var yT12 = stan::math::ode_bdf(ayt(), y0, t0d, ts,
-                                     nullptr, a)[0](0);
+  var yT12 = stan::math::ode_bdf(ayt(), y0, t0d, ts, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -452,16 +429,14 @@ TEST(StanMathOde_ode_bdf, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT13 = stan::math::ode_bdf(ayt(), y0, t0, tsd,
-                                     nullptr, ad)[0](0);
+  var yT13 = stan::math::ode_bdf(ayt(), y0, t0, tsd, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
   check_y0(y0);
   check_t0(t0);
 
-  var yT14 = stan::math::ode_bdf(ayt(), y0, t0, tsd,
-                                     nullptr, a)[0](0);
+  var yT14 = stan::math::ode_bdf(ayt(), y0, t0, tsd, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -469,8 +444,7 @@ TEST(StanMathOde_ode_bdf, arg_combos_test) {
   check_t0(t0);
   check_a(a);
 
-  var yT15 = stan::math::ode_bdf(ayt(), y0, t0, ts,
-                                     nullptr, ad)[0](0);
+  var yT15 = stan::math::ode_bdf(ayt(), y0, t0, ts, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -478,8 +452,7 @@ TEST(StanMathOde_ode_bdf, arg_combos_test) {
   check_t0(t0);
   check_ts(ts);
 
-  var yT16 = stan::math::ode_bdf(ayt(), y0, t0, ts,
-                                     nullptr, a)[0](0);
+  var yT16 = stan::math::ode_bdf(ayt(), y0, t0, ts, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
diff --git a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
index e97e6f43ef4..3697291e3a8 100644
--- a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
@@ -58,8 +58,7 @@ TEST(StanMathOde_ode_rk45, int_t0) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
-      = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
   EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
@@ -75,8 +74,7 @@ TEST(StanMathOde_ode_rk45, int_ts) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
-      = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
   EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
@@ -92,8 +90,7 @@ TEST(StanMathOde_ode_rk45, t0) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a);
 
   output[0][0].grad();
 
@@ -118,8 +115,7 @@ TEST(StanMathOde_ode_rk45, ts) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a);
 
   output[0][0].grad();
 
@@ -144,8 +140,7 @@ TEST(StanMathOde_ode_rk45, ts_repeat) {
   double a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a);
 
   output[0][0].grad();
 
@@ -183,8 +178,7 @@ TEST(StanMathOde_ode_rk45, scalar_arg) {
 
   var a = 1.5;
 
-  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a)[0][0];
 
   output.grad();
 
@@ -202,8 +196,7 @@ TEST(StanMathOde_ode_rk45, scalar_arg_multi_time) {
   var a = 1.5;
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
-      = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                nullptr, a);
+      = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a);
 
   output[0](0).grad();
 
@@ -227,8 +220,7 @@ TEST(StanMathOde_ode_rk45, std_vector_arg) {
 
   std::vector<var> a = {1.5};
 
-  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a)[0][0];
 
   output.grad();
 
@@ -246,8 +238,7 @@ TEST(StanMathOde_ode_rk45, vector_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a)[0][0];
 
   output.grad();
 
@@ -265,8 +256,7 @@ TEST(StanMathOde_ode_rk45, row_vector_arg) {
   Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a)[0][0];
 
   output.grad();
 
@@ -284,8 +274,7 @@ TEST(StanMathOde_ode_rk45, matrix_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
   a << 1.5;
 
-  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts,
-                                       nullptr, a)[0][0];
+  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a)[0][0];
 
   output.grad();
 
@@ -303,8 +292,8 @@ TEST(StanMathOde_ode_rk45, scalar_std_vector_args) {
   var a0 = 0.75;
   std::vector<var> a1 = {0.75};
 
-  var output = stan::math::ode_rk45(Cos2Arg(), y0, t0, ts,
-                                       nullptr, a0, a1)[0][0];
+  var output
+      = stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a0, a1)[0][0];
 
   output.grad();
 
@@ -362,57 +351,49 @@ TEST(StanMathOde_ode_rk45, arg_combos_test) {
                     exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
-  double yT1 = stan::math::ode_rk45(ayt(), y0d, t0d, tsd,
-                                       nullptr, ad)[0](0);
+  double yT1 = stan::math::ode_rk45(ayt(), y0d, t0d, tsd, nullptr, ad)[0](0);
   check_yT(yT1);
 
-  var yT2 = stan::math::ode_rk45(ayt(), y0d, t0d, tsd,
-                                    nullptr, a)[0](0);
+  var yT2 = stan::math::ode_rk45(ayt(), y0d, t0d, tsd, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
-  var yT3 = stan::math::ode_rk45(ayt(), y0d, t0d, ts,
-                                    nullptr, ad)[0](0);
+  var yT3 = stan::math::ode_rk45(ayt(), y0d, t0d, ts, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
-  var yT4 = stan::math::ode_rk45(ayt(), y0d, t0d, ts,
-                                    nullptr, a)[0](0);
+  var yT4 = stan::math::ode_rk45(ayt(), y0d, t0d, ts, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
   check_ts(ts);
   check_a(a);
 
-  var yT5 = stan::math::ode_rk45(ayt(), y0d, t0, tsd,
-                                    nullptr, ad)[0](0);
+  var yT5 = stan::math::ode_rk45(ayt(), y0d, t0, tsd, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
-  var yT6 = stan::math::ode_rk45(ayt(), y0d, t0, tsd,
-                                    nullptr, a)[0](0);
+  var yT6 = stan::math::ode_rk45(ayt(), y0d, t0, tsd, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
   check_t0(t0);
   check_a(a);
 
-  var yT7 = stan::math::ode_rk45(ayt(), y0d, t0, ts,
-                                    nullptr, ad)[0](0);
+  var yT7 = stan::math::ode_rk45(ayt(), y0d, t0, ts, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
   check_t0(t0);
   check_ts(ts);
 
-  var yT8 = stan::math::ode_rk45(ayt(), y0d, t0, ts,
-                                    nullptr, a)[0](0);
+  var yT8 = stan::math::ode_rk45(ayt(), y0d, t0, ts, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -420,31 +401,27 @@ TEST(StanMathOde_ode_rk45, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT9 = stan::math::ode_rk45(ayt(), y0, t0d, tsd,
-                                    nullptr, ad)[0](0);
+  var yT9 = stan::math::ode_rk45(ayt(), y0, t0d, tsd, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
-  var yT10 = stan::math::ode_rk45(ayt(), y0, t0d, tsd,
-                                     nullptr, a)[0](0);
+  var yT10 = stan::math::ode_rk45(ayt(), y0, t0d, tsd, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
   check_y0(y0);
   check_a(a);
 
-  var yT11 = stan::math::ode_rk45(ayt(), y0, t0d, ts,
-                                     nullptr, ad)[0](0);
+  var yT11 = stan::math::ode_rk45(ayt(), y0, t0d, ts, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
   check_y0(y0);
   check_ts(ts);
 
-  var yT12 = stan::math::ode_rk45(ayt(), y0, t0d, ts,
-                                     nullptr, a)[0](0);
+  var yT12 = stan::math::ode_rk45(ayt(), y0, t0d, ts, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -452,16 +429,14 @@ TEST(StanMathOde_ode_rk45, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT13 = stan::math::ode_rk45(ayt(), y0, t0, tsd,
-                                     nullptr, ad)[0](0);
+  var yT13 = stan::math::ode_rk45(ayt(), y0, t0, tsd, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
   check_y0(y0);
   check_t0(t0);
 
-  var yT14 = stan::math::ode_rk45(ayt(), y0, t0, tsd,
-                                     nullptr, a)[0](0);
+  var yT14 = stan::math::ode_rk45(ayt(), y0, t0, tsd, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -469,8 +444,7 @@ TEST(StanMathOde_ode_rk45, arg_combos_test) {
   check_t0(t0);
   check_a(a);
 
-  var yT15 = stan::math::ode_rk45(ayt(), y0, t0, ts,
-                                     nullptr, ad)[0](0);
+  var yT15 = stan::math::ode_rk45(ayt(), y0, t0, ts, nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -478,8 +452,7 @@ TEST(StanMathOde_ode_rk45, arg_combos_test) {
   check_t0(t0);
   check_ts(ts);
 
-  var yT16 = stan::math::ode_rk45(ayt(), y0, t0, ts,
-                                     nullptr, a)[0](0);
+  var yT16 = stan::math::ode_rk45(ayt(), y0, t0, ts, nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
diff --git a/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
index 5fa95d3da80..69c313af191 100644
--- a/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
@@ -59,7 +59,7 @@ TEST(StanMathOde_ode_rk45_tol, int_t0) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                 nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
   EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
@@ -76,7 +76,7 @@ TEST(StanMathOde_ode_rk45_tol, int_ts) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                 nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
   EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
@@ -93,7 +93,7 @@ TEST(StanMathOde_ode_rk45_tol, t0) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                 nullptr, a);
 
   output[0][0].grad();
 
@@ -119,7 +119,7 @@ TEST(StanMathOde_ode_rk45_tol, ts) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                 nullptr, a);
 
   output[0][0].grad();
 
@@ -145,7 +145,7 @@ TEST(StanMathOde_ode_rk45_tol, ts_repeat) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                 nullptr, a);
 
   output[0][0].grad();
 
@@ -184,7 +184,7 @@ TEST(StanMathOde_ode_rk45_tol, scalar_arg) {
   var a = 1.5;
 
   var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -203,7 +203,7 @@ TEST(StanMathOde_ode_rk45_tol, scalar_arg_multi_time) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                 nullptr, a);
 
   output[0](0).grad();
 
@@ -228,7 +228,7 @@ TEST(StanMathOde_ode_rk45_tol, std_vector_arg) {
   std::vector<var> a = {1.5};
 
   var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -247,7 +247,7 @@ TEST(StanMathOde_ode_rk45_tol, vector_arg) {
   a << 1.5;
 
   var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -266,7 +266,7 @@ TEST(StanMathOde_ode_rk45_tol, row_vector_arg) {
   a << 1.5;
 
   var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -285,7 +285,7 @@ TEST(StanMathOde_ode_rk45_tol, matrix_arg) {
   a << 1.5;
 
   var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -304,7 +304,7 @@ TEST(StanMathOde_ode_rk45_tol, scalar_std_vector_args) {
   std::vector<var> a1 = {0.75};
 
   var output = stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a0, a1)[0][0];
+                                        nullptr, a0, a1)[0][0];
 
   output.grad();
 
@@ -363,25 +363,25 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   };
 
   double yT1 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                       nullptr, ad)[0](0);
+                                        nullptr, ad)[0](0);
   check_yT(yT1);
 
   var yT2 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
   var yT3 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
   var yT4 = stan::math::ode_rk45_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
@@ -389,14 +389,14 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   check_a(a);
 
   var yT5 = stan::math::ode_rk45_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
   var yT6 = stan::math::ode_rk45_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
@@ -404,7 +404,7 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   check_a(a);
 
   var yT7 = stan::math::ode_rk45_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
@@ -412,7 +412,7 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   check_ts(ts);
 
   var yT8 = stan::math::ode_rk45_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -421,14 +421,14 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   check_a(a);
 
   var yT9 = stan::math::ode_rk45_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
   var yT10 = stan::math::ode_rk45_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
@@ -436,7 +436,7 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   check_a(a);
 
   var yT11 = stan::math::ode_rk45_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
@@ -444,7 +444,7 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   check_ts(ts);
 
   var yT12 = stan::math::ode_rk45_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -453,7 +453,7 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   check_a(a);
 
   var yT13 = stan::math::ode_rk45_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
@@ -461,7 +461,7 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   check_t0(t0);
 
   var yT14 = stan::math::ode_rk45_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -470,7 +470,7 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   check_a(a);
 
   var yT15 = stan::math::ode_rk45_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -479,7 +479,7 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   check_ts(ts);
 
   var yT16 = stan::math::ode_rk45_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);

From 961780f427e52a43117d08ba649def2f34bf901a Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Tue, 16 Jun 2020 19:30:07 -0400
Subject: [PATCH 134/189] Performance optimizations for coupled_ode_system
 (design-doc #19)

---
 stan/math/rev/functor/coupled_ode_system.hpp | 45 +++++++++++---------
 stan/math/rev/functor/cvodes_integrator.hpp  | 14 +++---
 2 files changed, 32 insertions(+), 27 deletions(-)

diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index 61205cee3eb..187bf4da63e 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -71,6 +71,8 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
   const size_t y0_vars_;
   const size_t args_vars_;
   const size_t N_;
+  Eigen::VectorXd args_adjoints_;
+  Eigen::VectorXd y_adjoints_;
   std::ostream* msgs_;
 
   /**
@@ -94,6 +96,8 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
         y0_vars_(count_vars(y0_)),
         args_vars_(count_vars(args...)),
         N_(y0.size()),
+	args_adjoints_(args_vars_),
+	y_adjoints_(N_),
         msgs_(msgs) {}
 
   /**
@@ -111,7 +115,7 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
    *    expected number of derivatives, N.
    */
   void operator()(const Eigen::VectorXd& z, Eigen::VectorXd& dz_dt,
-                  double t) const {
+                  double t) {
     using std::vector;
 
     dz_dt.resize(size());
@@ -137,40 +141,41 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
     check_size_match("coupled_ode_system", "dy_dt", f_y_t_vars.size(), "states",
                      N_);
 
-    Eigen::VectorXd args_adjoints(args_vars_);
-    for (size_t i = 0; i < N_; i++) {
+    for (size_t i = 0; i < N_; ++i) {
       dz_dt(i) = f_y_t_vars(i).val();
       f_y_t_vars(i).grad();
 
-      for (size_t j = 0; j < y0_vars_; j++) {
+      y_adjoints_ = y_vars.adj();
+
+      memset(args_adjoints_.data(), 0, sizeof(double) * args_vars_);
+      apply(
+          [&](auto&&... args) {
+            accumulate_adjoints(args_adjoints_.data(), args...);
+          },
+          local_args_tuple);
+
+      nested.set_zero_all_adjoints();
+
+      for (size_t j = 0; j < y0_vars_; ++j) {
         // orders derivatives by equation (i.e. if there are 2 eqns
         // (y1, y2) and 2 parameters (a, b), dy_dt will be ordered as:
         // dy1_dt, dy2_dt, dy1_da, dy2_da, dy1_db, dy2_db
-        double temp_deriv = 0;
-        for (size_t k = 0; k < N_; k++) {
-          temp_deriv += z[N_ + N_ * j + k] * y_vars[k].adj();
+        double temp_deriv = 0.0;
+        for (size_t k = 0; k < N_; ++k) {
+          temp_deriv += z[N_ + N_ * j + k] * y_adjoints_[k];
         }
 
         dz_dt[N_ + N_ * j + i] = temp_deriv;
       }
 
-      args_adjoints.setZero();
-      apply(
-          [&](auto&&... args) {
-            accumulate_adjoints(args_adjoints.data(), args...);
-          },
-          local_args_tuple);
-
-      for (size_t j = 0; j < args_vars_; j++) {
-        double temp_deriv = args_adjoints(j);
-        for (size_t k = 0; k < N_; k++) {
-          temp_deriv += z[N_ + N_ * y0_vars_ + N_ * j + k] * y_vars[k].adj();
+      for (size_t j = 0; j < args_vars_; ++j) {
+        double temp_deriv = args_adjoints_[j];
+        for (size_t k = 0; k < N_; ++k) {
+          temp_deriv += z[N_ + N_ * y0_vars_ + N_ * j + k] * y_adjoints_[k];
         }
 
         dz_dt[N_ + N_ * y0_vars_ + N_ * j + i] = temp_deriv;
       }
-
-      nested.set_zero_all_adjoints();
     }
   }
 
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 7a0ccd0651b..c530aa3014f 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -62,8 +62,8 @@ class cvodes_integrator {
    * ODE RHS passed to CVODES.
    */
   static int cv_rhs(realtype t, N_Vector y, N_Vector ydot, void* user_data) {
-    const cvodes_integrator* integrator
-        = static_cast<const cvodes_integrator*>(user_data);
+    cvodes_integrator* integrator
+        = static_cast<cvodes_integrator*>(user_data);
     integrator->rhs(t, NV_DATA_S(y), NV_DATA_S(ydot));
     return 0;
   }
@@ -75,8 +75,8 @@ class cvodes_integrator {
   static int cv_rhs_sens(int Ns, realtype t, N_Vector y, N_Vector ydot,
                          N_Vector* yS, N_Vector* ySdot, void* user_data,
                          N_Vector tmp1, N_Vector tmp2) {
-    const cvodes_integrator* integrator
-        = static_cast<const cvodes_integrator*>(user_data);
+    cvodes_integrator* integrator
+      = static_cast<cvodes_integrator*>(user_data);
     integrator->rhs_sens(t, NV_DATA_S(y), yS, ySdot);
     return 0;
   }
@@ -90,8 +90,8 @@ class cvodes_integrator {
   static int cv_jacobian_states(realtype t, N_Vector y, N_Vector fy,
                                 SUNMatrix J, void* user_data, N_Vector tmp1,
                                 N_Vector tmp2, N_Vector tmp3) {
-    const cvodes_integrator* integrator
-        = static_cast<const cvodes_integrator*>(user_data);
+    cvodes_integrator* integrator
+        = static_cast<cvodes_integrator*>(user_data);
     integrator->jacobian_states(t, NV_DATA_S(y), J);
     return 0;
   }
@@ -142,7 +142,7 @@ class cvodes_integrator {
    * which CVODES separates from the main ODE RHS.
    */
   inline void rhs_sens(double t, const double y[], N_Vector* yS,
-                       N_Vector* ySdot) const {
+                       N_Vector* ySdot) {
     Eigen::VectorXd z(coupled_state_.size());
     Eigen::VectorXd dz_dt;
     std::copy(y, y + N_, z.data());

From 5668b09706cc56d50b4e9db70fb9b9cf48bf41c9 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 22 Jun 2020 19:53:16 +0000
Subject: [PATCH 135/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

---
 stan/math/prim/functor/ode_rk45.hpp               |  4 ++--
 stan/math/rev/functor/coupled_ode_system.hpp      |  7 +++----
 stan/math/rev/functor/cvodes_integrator.hpp       | 12 +++++-------
 test/unit/math/rev/functor/ode_adams_rev_test.cpp | 10 +++++-----
 test/unit/math/rev/functor/ode_bdf_rev_test.cpp   | 10 +++++-----
 test/unit/math/rev/functor/ode_rk45_rev_test.cpp  | 10 +++++-----
 6 files changed, 25 insertions(+), 28 deletions(-)

diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index cbbed1890e2..dcf32101857 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -172,8 +172,8 @@ ode_rk45_tol(const F& f,
  */
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... Args>
-std::vector<
-  Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, Args...>, Eigen::Dynamic, 1>>
+std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, Args...>,
+                          Eigen::Dynamic, 1>>
 ode_rk45(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
          T_t0 t0, const std::vector<T_ts>& ts, std::ostream* msgs,
          const Args&... args) {
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index 187bf4da63e..c3581df884e 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -96,8 +96,8 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
         y0_vars_(count_vars(y0_)),
         args_vars_(count_vars(args...)),
         N_(y0.size()),
-	args_adjoints_(args_vars_),
-	y_adjoints_(N_),
+        args_adjoints_(args_vars_),
+        y_adjoints_(N_),
         msgs_(msgs) {}
 
   /**
@@ -114,8 +114,7 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
    * @throw exception if the base ode function does not return the
    *    expected number of derivatives, N.
    */
-  void operator()(const Eigen::VectorXd& z, Eigen::VectorXd& dz_dt,
-                  double t) {
+  void operator()(const Eigen::VectorXd& z, Eigen::VectorXd& dz_dt, double t) {
     using std::vector;
 
     dz_dt.resize(size());
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 98f80c99aa2..ee18c9de64d 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -38,7 +38,8 @@ class cvodes_integrator {
   const T_t0 t0_;
   const std::vector<T_ts>& ts_;
   std::tuple<const T_Args&...> args_tuple_;
-  std::tuple<plain_type_t<decltype(value_of(T_Args()))>...> value_of_args_tuple_;
+  std::tuple<plain_type_t<decltype(value_of(T_Args()))>...>
+      value_of_args_tuple_;
   const size_t N_;
   std::ostream* msgs_;
   double relative_tolerance_;
@@ -62,8 +63,7 @@ class cvodes_integrator {
    * ODE RHS passed to CVODES.
    */
   static int cv_rhs(realtype t, N_Vector y, N_Vector ydot, void* user_data) {
-    cvodes_integrator* integrator
-        = static_cast<cvodes_integrator*>(user_data);
+    cvodes_integrator* integrator = static_cast<cvodes_integrator*>(user_data);
     integrator->rhs(t, NV_DATA_S(y), NV_DATA_S(ydot));
     return 0;
   }
@@ -75,8 +75,7 @@ class cvodes_integrator {
   static int cv_rhs_sens(int Ns, realtype t, N_Vector y, N_Vector ydot,
                          N_Vector* yS, N_Vector* ySdot, void* user_data,
                          N_Vector tmp1, N_Vector tmp2) {
-    cvodes_integrator* integrator
-      = static_cast<cvodes_integrator*>(user_data);
+    cvodes_integrator* integrator = static_cast<cvodes_integrator*>(user_data);
     integrator->rhs_sens(t, NV_DATA_S(y), yS, ySdot);
     return 0;
   }
@@ -90,8 +89,7 @@ class cvodes_integrator {
   static int cv_jacobian_states(realtype t, N_Vector y, N_Vector fy,
                                 SUNMatrix J, void* user_data, N_Vector tmp1,
                                 N_Vector tmp2, N_Vector tmp3) {
-    cvodes_integrator* integrator
-        = static_cast<cvodes_integrator*>(user_data);
+    cvodes_integrator* integrator = static_cast<cvodes_integrator*>(user_data);
     integrator->jacobian_states(t, NV_DATA_S(y), J);
     return 0;
   }
diff --git a/test/unit/math/rev/functor/ode_adams_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
index d5e62e00e1a..b164aeb1427 100644
--- a/test/unit/math/rev/functor/ode_adams_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
@@ -27,11 +27,12 @@ auto sum_(Vec&& arg) {
 struct CosArg1 {
   template <typename T0, typename T_y, typename... T_Args>
   inline Eigen::Matrix<stan::return_type_t<T_y, T_Args...>, Eigen::Dynamic, 1>
-  operator()(const T0& t, const T_y& y,
-             std::ostream* msgs, const T_Args&... a) const {
+  operator()(const T0& t, const T_y& y, std::ostream* msgs,
+             const T_Args&... a) const {
     std::vector<typename stan::return_type<T0, T_Args...>::type> vec
         = {sum_(a)...};
-    Eigen::Matrix<stan::return_type_t<T_y, T_Args...>, Eigen::Dynamic, 1> out(1);
+    Eigen::Matrix<stan::return_type_t<T_y, T_Args...>, Eigen::Dynamic, 1> out(
+        1);
     out << stan::math::cos(sum_(vec) * t);
     return out;
   }
@@ -305,8 +306,7 @@ TEST(StanMathOde_ode_adams, scalar_std_vector_args) {
 struct ayt {
   template <typename T0, typename T_y, typename T2>
   inline Eigen::Matrix<stan::return_type_t<T_y, T2>, Eigen::Dynamic, 1>
-  operator()(const T0& t, const T_y& y,
-             std::ostream* msgs, const T2& a) const {
+  operator()(const T0& t, const T_y& y, std::ostream* msgs, const T2& a) const {
     return -a * y * t;
   }
 };
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index da7a30dd6d6..9c6284f8a6e 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -27,11 +27,12 @@ auto sum_(Vec&& arg) {
 struct CosArg1 {
   template <typename T0, typename T_y, typename... T_Args>
   inline Eigen::Matrix<stan::return_type_t<T_y, T_Args...>, Eigen::Dynamic, 1>
-  operator()(const T0& t, const T_y& y,
-             std::ostream* msgs, const T_Args&... a) const {
+  operator()(const T0& t, const T_y& y, std::ostream* msgs,
+             const T_Args&... a) const {
     std::vector<typename stan::return_type<T0, T_Args...>::type> vec
         = {sum_(a)...};
-    Eigen::Matrix<stan::return_type_t<T_y, T_Args...>, Eigen::Dynamic, 1> out(1);
+    Eigen::Matrix<stan::return_type_t<T_y, T_Args...>, Eigen::Dynamic, 1> out(
+        1);
     out << stan::math::cos(sum_(vec) * t);
     return out;
   }
@@ -305,8 +306,7 @@ TEST(StanMathOde_ode_bdf, scalar_std_vector_args) {
 struct ayt {
   template <typename T0, typename T_y, typename T2>
   inline Eigen::Matrix<stan::return_type_t<T_y, T2>, Eigen::Dynamic, 1>
-  operator()(const T0& t, const T_y& y,
-             std::ostream* msgs, const T2& a) const {
+  operator()(const T0& t, const T_y& y, std::ostream* msgs, const T2& a) const {
     return -a * y * t;
   }
 };
diff --git a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
index 16cd6e7429e..4c06a75fe77 100644
--- a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
@@ -27,11 +27,12 @@ auto sum_(Vec&& arg) {
 struct CosArg1 {
   template <typename T0, typename T_y, typename... T_Args>
   inline Eigen::Matrix<stan::return_type_t<T_y, T_Args...>, Eigen::Dynamic, 1>
-  operator()(const T0& t, const T_y& y,
-             std::ostream* msgs, const T_Args&... a) const {
+  operator()(const T0& t, const T_y& y, std::ostream* msgs,
+             const T_Args&... a) const {
     std::vector<typename stan::return_type<T0, T_Args...>::type> vec
         = {sum_(a)...};
-    Eigen::Matrix<stan::return_type_t<T_y, T_Args...>, Eigen::Dynamic, 1> out(1);
+    Eigen::Matrix<stan::return_type_t<T_y, T_Args...>, Eigen::Dynamic, 1> out(
+        1);
     out << stan::math::cos(sum_(vec) * t);
     return out;
   }
@@ -305,8 +306,7 @@ TEST(StanMathOde_ode_rk45, scalar_std_vector_args) {
 struct ayt {
   template <typename T0, typename T_y, typename T2>
   inline Eigen::Matrix<stan::return_type_t<T_y, T2>, Eigen::Dynamic, 1>
-  operator()(const T0& t, const T_y& y,
-             std::ostream* msgs, const T2& a) const {
+  operator()(const T0& t, const T_y& y, std::ostream* msgs, const T2& a) const {
     return -a * y * t;
   }
 };

From 11605da20f8795bc71d491fefe502a19e19d6dcd Mon Sep 17 00:00:00 2001
From: Rok Cesnovar <rok.cesnovar@fri.uni-lj.si>
Date: Tue, 23 Jun 2020 08:32:44 +0200
Subject: [PATCH 136/189] fix linting/docs errors

---
 stan/math/prim/functor/coupled_ode_system.hpp  |  4 +---
 ...egrate_ode_std_vector_interface_adapter.hpp |  2 +-
 stan/math/prim/functor/ode_rk45.hpp            | 11 ++++-------
 .../prim/functor/ode_store_sensitivities.hpp   |  2 +-
 stan/math/rev/functor/coupled_ode_system.hpp   |  5 +----
 stan/math/rev/functor/cvodes_integrator.hpp    |  7 +++++--
 stan/math/rev/functor/ode_adams.hpp            | 15 +++++++--------
 stan/math/rev/functor/ode_bdf.hpp              | 16 ++++++++--------
 .../rev/functor/ode_store_sensitivities.hpp    |  4 ++--
 .../math/rev/functor/ode_bdf_tol_prim_test.cpp | 18 +++++++++---------
 10 files changed, 39 insertions(+), 45 deletions(-)

diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
index 004dfb8009c..ceaae36b437 100644
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -78,10 +78,8 @@ struct coupled_ode_system_impl<true, F, T_initial, Args...> {
    *
    * @param[in] f the base ODE system functor
    * @param[in] y0 the initial state of the base ode
-   * @param[in] theta parameters of the base ode
-   * @param[in] x real data
-   * @param[in] x_int integer data
    * @param[in, out] msgs stream for messages
+   * @param[in] args other additional arguments
    */
   coupled_ode_system_impl(const F& f, const Eigen::VectorXd& y0,
                           std::ostream* msgs, const Args&... args)
diff --git a/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp b/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp
index 351387a7abf..36b65e4402f 100644
--- a/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp
+++ b/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp
@@ -23,7 +23,7 @@ template <typename F>
 struct integrate_ode_std_vector_interface_adapter {
   const F f_;
 
-  integrate_ode_std_vector_interface_adapter(const F& f) : f_(f) {}
+  explicit integrate_ode_std_vector_interface_adapter(const F& f) : f_(f) {}
 
   template <typename T0, typename T1, typename T2>
   auto operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index dcf32101857..adb0e433152 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -37,7 +37,7 @@ namespace math {
  * @tparam T_Args Types of pass-through parameters
  *
  * @param f Right hand side of the ODE
- * @param y0 Initial state
+ * @param y0_arg Initial state
  * @param t0 Initial time
  * @param ts Times at which to solve the ODE at. All values must be sorted and
  *   greater than t0.
@@ -56,7 +56,8 @@ std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, Args...>,
 ode_rk45_tol(const F& f,
              const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_arg, T_t0 t0,
              const std::vector<T_ts>& ts, double relative_tolerance,
-             double absolute_tolerance, long int max_num_steps,
+             double absolute_tolerance,
+             long int max_num_steps,  // NOLINT(runtime/int)
              std::ostream* msgs, const Args&... args) {
   using boost::numeric::odeint::integrate_times;
   using boost::numeric::odeint::make_dense_output;
@@ -162,10 +163,6 @@ ode_rk45_tol(const F& f,
  * @param t0 Initial time
  * @param ts Times at which to solve the ODE at. All values must be sorted and
  *   greather than t0.
- * @param relative_tolerance Relative tolerance passed to CVODES
- * @param absolute_tolerance Absolute tolerance passed to CVODES
- * @param max_num_steps Upper limit on the number of integration steps to
- *   take between each output (error if exceeded)
  * @param[in, out] msgs the print stream for warning messages
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return Solution to ODE at times \p ts
@@ -179,7 +176,7 @@ ode_rk45(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
          const Args&... args) {
   double relative_tolerance = 1e-10;
   double absolute_tolerance = 1e-10;
-  long int max_num_steps = 1e8;
+  long int max_num_steps = 1e8;  // NOLINT(runtime/int)
 
   return ode_rk45_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
                       max_num_steps, msgs, args...);
diff --git a/stan/math/prim/functor/ode_store_sensitivities.hpp b/stan/math/prim/functor/ode_store_sensitivities.hpp
index 8d394a41eb5..cf5a5fb2b86 100644
--- a/stan/math/prim/functor/ode_store_sensitivities.hpp
+++ b/stan/math/prim/functor/ode_store_sensitivities.hpp
@@ -18,7 +18,7 @@ namespace math {
  * @param coupled_state Current state of the coupled_ode_system
  * @param y0 Initial state
  * @param t0 Initial time
- * @param ts Times at which to solve the ODE at
+ * @param t Times at which to solve the ODE at
  * @param[in, out] msgs the print stream for warning messages
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return ODE state
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index c3581df884e..a5370b37f9a 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -5,7 +5,6 @@
 #include <stan/math/prim/functor/coupled_ode_system.hpp>
 #include <stan/math/rev/functor/cvodes_utils.hpp>
 #include <stan/math/rev/meta.hpp>
-#include <stan/math/rev/fun/value_of.hpp>
 #include <stan/math/rev/core.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stdexcept>
@@ -82,10 +81,8 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
    *
    * @param[in] f the base ODE system functor
    * @param[in] y0 the initial state of the base ode
-   * @param[in] theta parameters of the base ode
-   * @param[in] x real data
-   * @param[in] x_int integer data
    * @param[in, out] msgs stream for messages
+   * @param[in] args other additional arguments
    */
   coupled_ode_system_impl(const F& f,
                           const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index ee18c9de64d..908805bd14e 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -45,7 +45,7 @@ class cvodes_integrator {
   double relative_tolerance_;
   double absolute_tolerance_;
   bool include_sensitivities_in_errors_;
-  long int max_num_steps_;
+  long int max_num_steps_;  // NOLINT(runtime/int)
 
   const size_t y0_vars_;
   const size_t args_vars_;
@@ -166,6 +166,8 @@ class cvodes_integrator {
    *   not less than t0.
    * @param relative_tolerance Relative tolerance passed to CVODES
    * @param absolute_tolerance Absolute tolerance passed to CVODES
+   * @param include_sensitivities_in_errors A bool to determine whether
+   * to store the sensitivities in errors
    * @param max_num_steps Upper limit on the number of integration steps to
    *   take between each output (error if exceeded)
    * @param[in, out] msgs the print stream for warning messages
@@ -185,7 +187,8 @@ class cvodes_integrator {
                     const T_t0& t0, const std::vector<T_ts>& ts,
                     double relative_tolerance, double absolute_tolerance,
                     bool include_sensitivities_in_errors,
-                    long int max_num_steps, std::ostream* msgs,
+                    long int max_num_steps,  // NOLINT(runtime/int)
+                    std::ostream* msgs,
                     const T_Args&... args)
       : f_(f),
         y0_(y0.unaryExpr([](const T_y0& val) { return T_y0_t0(val); })),
diff --git a/stan/math/rev/functor/ode_adams.hpp b/stan/math/rev/functor/ode_adams.hpp
index 15beb0a11af..0fdd68d91b8 100644
--- a/stan/math/rev/functor/ode_adams.hpp
+++ b/stan/math/rev/functor/ode_adams.hpp
@@ -17,7 +17,8 @@ ode_adams_tol_sens_error(const F& f,
                          const T_t0& t0, const std::vector<T_ts>& ts,
                          double rtol, double atol, double rtols,
                          const std::vector<double>& atols,
-                         long int max_num_steps, std::ostream* msgs,
+                         long int max_num_steps,  // NOLINT(runtime/int)
+                         std::ostream* msgs,
                          const T_Args&... args) {
   cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
       f, y0, t0, ts, rtol, atol, true, max_num_steps, msgs, args...);
@@ -33,7 +34,8 @@ ode_adams_tol_error(const F& f,
                     const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
                     const T_t0& t0, const std::vector<T_ts>& ts,
                     double relative_tolerance, double absolute_tolerance,
-                    long int max_num_steps, std::ostream* msgs,
+                    long int max_num_steps,  // NOLINT(runtime/int)
+                    std::ostream* msgs,
                     const T_Args&... args) {
   cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
       f, y0, t0, ts, relative_tolerance, absolute_tolerance, true,
@@ -82,7 +84,8 @@ std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
 ode_adams_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
               const T_t0& t0, const std::vector<T_ts>& ts,
               double relative_tolerance, double absolute_tolerance,
-              long int max_num_steps, std::ostream* msgs,
+              long int max_num_steps,  // NOLINT(runtime/int)
+              std::ostream* msgs,
               const T_Args&... args) {
   cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
       f, y0, t0, ts, relative_tolerance, absolute_tolerance, false,
@@ -117,10 +120,6 @@ ode_adams_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
  * @param t0 Initial time
  * @param ts Times at which to solve the ODE at. All values must be sorted and
  *   not less than t0.
- * @param relative_tolerance Relative tolerance passed to CVODES
- * @param absolute_tolerance Absolute tolerance passed to CVODES
- * @param max_num_steps Upper limit on the number of integration steps to
- *   take between each output (error if exceeded)
  * @param[in, out] msgs the print stream for warning messages
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return Solution to ODE at times \p ts
@@ -134,7 +133,7 @@ ode_adams(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
           const T_Args&... args) {
   double relative_tolerance = 1e-10;
   double absolute_tolerance = 1e-10;
-  long int max_num_steps = 1e8;
+  long int max_num_steps = 1e8;  // NOLINT(runtime/int)
 
   return ode_adams_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
                        max_num_steps, msgs, args...);
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 7f16b35c417..874bd65d7dd 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -17,7 +17,8 @@ ode_bdf_tol_sens_error(const F& f,
                        const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
                        const T_t0& t0, const std::vector<T_ts>& ts, double rtol,
                        double atol, double rtols,
-                       const std::vector<double>& atols, long int max_num_steps,
+                       const std::vector<double>& atols,
+                       long int max_num_steps,  // NOLINT(runtime/int)
                        std::ostream* msgs, const T_Args&... args) {
   cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
       f, y0, t0, ts, rtol, atol, true, max_num_steps, msgs, args...);
@@ -33,7 +34,8 @@ ode_bdf_tol_error(const F& f,
                   const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
                   const T_t0& t0, const std::vector<T_ts>& ts,
                   double relative_tolerance, double absolute_tolerance,
-                  long int max_num_steps, std::ostream* msgs,
+                  long int max_num_steps,  // NOLINT(runtime/int)
+                  std::ostream* msgs,
                   const T_Args&... args) {
   cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
       f, y0, t0, ts, relative_tolerance, absolute_tolerance, true,
@@ -82,7 +84,9 @@ std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
 ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
             const T_t0& t0, const std::vector<T_ts>& ts,
             double relative_tolerance, double absolute_tolerance,
-            long int max_num_steps, std::ostream* msgs, const T_Args&... args) {
+            long int max_num_steps,  // NOLINT(runtime/int)
+            std::ostream* msgs,
+            const T_Args&... args) {
   cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
       f, y0, t0, ts, relative_tolerance, absolute_tolerance, false,
       max_num_steps, msgs, args...);
@@ -116,10 +120,6 @@ ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
  * @param t0 Initial time
  * @param ts Times at which to solve the ODE at. All values must be sorted and
  *   not less than t0.
- * @param relative_tolerance Relative tolerance passed to CVODES
- * @param absolute_tolerance Absolute tolerance passed to CVODES
- * @param max_num_steps Upper limit on the number of integration steps to
- *   take between each output (error if exceeded)
  * @param[in, out] msgs the print stream for warning messages
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return Solution to ODE at times \p ts
@@ -133,7 +133,7 @@ ode_bdf(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
         const T_Args&... args) {
   double relative_tolerance = 1e-10;
   double absolute_tolerance = 1e-10;
-  long int max_num_steps = 1e8;
+  long int max_num_steps = 1e8;  // NOLINT(runtime/int)
 
   return ode_bdf_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
                      max_num_steps, msgs, args...);
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 725f5731a9e..aaf02ff972e 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -25,7 +25,7 @@ namespace math {
  * @param coupled_state Current state of the coupled_ode_system
  * @param y0 Initial state
  * @param t0 Initial time
- * @param ts Times at which to solve the ODE at
+ * @param t Times at which to solve the ODE at
  * @param[in, out] msgs the print stream for warning messages
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return ODE state with scalar type var
@@ -69,7 +69,7 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
     // iterate over parameters for each equation
     varis_ptr = save_varis(varis_ptr, y0);
     for (std::size_t k = 0; k < y0_vars; ++k) {
-      //*varis_ptr = y0[k].vi_;
+      // *varis_ptr = y0[k].vi_;
       *partials_ptr = coupled_state(N + y0_vars * k + j);
       partials_ptr++;
     }
diff --git a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
index 33242f813cc..c9c4a9dbe9d 100644
--- a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
@@ -59,7 +59,7 @@ struct CosArgWrongSize {
   }
 };
 
-TEST(ode_bdf_prim, y0_errors) {
+TEST(ode_bdf_tol_prim, y0_errors) {
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   Eigen::VectorXd y0inf(1);
   Eigen::VectorXd y0NaN(1);
@@ -87,7 +87,7 @@ TEST(ode_bdf_prim, y0_errors) {
                std::invalid_argument);
 }
 
-TEST(ode_bdf_prim, t0_errors) {
+TEST(ode_bdf_tol_prim, t0_errors) {
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0;
   double t0inf = stan::math::INFTY;
@@ -108,7 +108,7 @@ TEST(ode_bdf_prim, t0_errors) {
                std::domain_error);
 }
 
-TEST(ode_bdf_prim, ts_errors) {
+TEST(ode_bdf_tol_prim, ts_errors) {
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0;
   std::vector<double> ts = {0.45, 1.1};
@@ -148,7 +148,7 @@ TEST(ode_bdf_prim, ts_errors) {
                std::domain_error);
 }
 
-TEST(ode_bdf_prim, one_arg_errors) {
+TEST(ode_bdf_tol_prim, one_arg_errors) {
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0;
   std::vector<double> ts = {0.45, 1.1};
@@ -202,7 +202,7 @@ TEST(ode_bdf_prim, one_arg_errors) {
                std::domain_error);
 }
 
-TEST(ode_bdf_prim, two_arg_errors) {
+TEST(ode_bdf_tol_prim, two_arg_errors) {
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0;
   std::vector<double> ts = {0.45, 1.1};
@@ -256,7 +256,7 @@ TEST(ode_bdf_prim, two_arg_errors) {
                std::domain_error);
 }
 
-TEST(ode_bdf_prim, rtol_errors) {
+TEST(ode_bdf_tol_prim, rtol_errors) {
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0;
   std::vector<double> ts = {0.45, 1.1};
@@ -284,7 +284,7 @@ TEST(ode_bdf_prim, rtol_errors) {
                std::domain_error);
 }
 
-TEST(ode_bdf_prim, atol_errors) {
+TEST(ode_bdf_tol_prim, atol_errors) {
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0;
   std::vector<double> ts = {0.45, 1.1};
@@ -312,7 +312,7 @@ TEST(ode_bdf_prim, atol_errors) {
                std::domain_error);
 }
 
-TEST(ode_bdf_prim, max_num_steps_errors) {
+TEST(ode_bdf_tol_prim, max_num_steps_errors) {
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0;
   std::vector<double> ts = {0.45, 1.1};
@@ -335,7 +335,7 @@ TEST(ode_bdf_prim, max_num_steps_errors) {
                std::domain_error);
 }
 
-TEST(ode_bdf_prim, rhs_wrong_size_errors) {
+TEST(ode_bdf_tol_prim, rhs_wrong_size_errors) {
   Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
   double t0 = 0;
   std::vector<double> ts = {0.45, 1.1};

From 28affd28d62acb128fb4004bf591269a00fd609e Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Tue, 23 Jun 2020 02:34:03 -0400
Subject: [PATCH 137/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 stan/math/rev/functor/cvodes_integrator.hpp | 3 +--
 stan/math/rev/functor/ode_adams.hpp         | 9 +++------
 stan/math/rev/functor/ode_bdf.hpp           | 6 ++----
 3 files changed, 6 insertions(+), 12 deletions(-)

diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 908805bd14e..e6f6de8846f 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -188,8 +188,7 @@ class cvodes_integrator {
                     double relative_tolerance, double absolute_tolerance,
                     bool include_sensitivities_in_errors,
                     long int max_num_steps,  // NOLINT(runtime/int)
-                    std::ostream* msgs,
-                    const T_Args&... args)
+                    std::ostream* msgs, const T_Args&... args)
       : f_(f),
         y0_(y0.unaryExpr([](const T_y0& val) { return T_y0_t0(val); })),
         t0_(t0),
diff --git a/stan/math/rev/functor/ode_adams.hpp b/stan/math/rev/functor/ode_adams.hpp
index 0fdd68d91b8..9735635b1d0 100644
--- a/stan/math/rev/functor/ode_adams.hpp
+++ b/stan/math/rev/functor/ode_adams.hpp
@@ -18,8 +18,7 @@ ode_adams_tol_sens_error(const F& f,
                          double rtol, double atol, double rtols,
                          const std::vector<double>& atols,
                          long int max_num_steps,  // NOLINT(runtime/int)
-                         std::ostream* msgs,
-                         const T_Args&... args) {
+                         std::ostream* msgs, const T_Args&... args) {
   cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
       f, y0, t0, ts, rtol, atol, true, max_num_steps, msgs, args...);
 
@@ -35,8 +34,7 @@ ode_adams_tol_error(const F& f,
                     const T_t0& t0, const std::vector<T_ts>& ts,
                     double relative_tolerance, double absolute_tolerance,
                     long int max_num_steps,  // NOLINT(runtime/int)
-                    std::ostream* msgs,
-                    const T_Args&... args) {
+                    std::ostream* msgs, const T_Args&... args) {
   cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
       f, y0, t0, ts, relative_tolerance, absolute_tolerance, true,
       max_num_steps, msgs, args...);
@@ -85,8 +83,7 @@ ode_adams_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
               const T_t0& t0, const std::vector<T_ts>& ts,
               double relative_tolerance, double absolute_tolerance,
               long int max_num_steps,  // NOLINT(runtime/int)
-              std::ostream* msgs,
-              const T_Args&... args) {
+              std::ostream* msgs, const T_Args&... args) {
   cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
       f, y0, t0, ts, relative_tolerance, absolute_tolerance, false,
       max_num_steps, msgs, args...);
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 874bd65d7dd..32c2c974baf 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -35,8 +35,7 @@ ode_bdf_tol_error(const F& f,
                   const T_t0& t0, const std::vector<T_ts>& ts,
                   double relative_tolerance, double absolute_tolerance,
                   long int max_num_steps,  // NOLINT(runtime/int)
-                  std::ostream* msgs,
-                  const T_Args&... args) {
+                  std::ostream* msgs, const T_Args&... args) {
   cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
       f, y0, t0, ts, relative_tolerance, absolute_tolerance, true,
       max_num_steps, msgs, args...);
@@ -85,8 +84,7 @@ ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
             const T_t0& t0, const std::vector<T_ts>& ts,
             double relative_tolerance, double absolute_tolerance,
             long int max_num_steps,  // NOLINT(runtime/int)
-            std::ostream* msgs,
-            const T_Args&... args) {
+            std::ostream* msgs, const T_Args&... args) {
   cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
       f, y0, t0, ts, relative_tolerance, absolute_tolerance, false,
       max_num_steps, msgs, args...);

From c42eec75ce014a73d6a6ad50748176884f00af77 Mon Sep 17 00:00:00 2001
From: Rok Cesnovar <rok.cesnovar@fri.uni-lj.si>
Date: Tue, 23 Jun 2020 08:58:13 +0200
Subject: [PATCH 138/189] fix missing headers

---
 stan/math/rev/functor/cvodes_integrator.hpp   | 1 +
 stan/math/rev/functor/integrate_ode_adams.hpp | 1 +
 2 files changed, 2 insertions(+)

diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index e6f6de8846f..3cb74a6c17a 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -8,6 +8,7 @@
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/value_of.hpp>
 #include <cvodes/cvodes.h>
+#include <nvector/nvector_serial.h>
 #include <sunlinsol/sunlinsol_dense.h>
 #include <algorithm>
 #include <ostream>
diff --git a/stan/math/rev/functor/integrate_ode_adams.hpp b/stan/math/rev/functor/integrate_ode_adams.hpp
index f108ef9a7e0..ef339e1bdbf 100644
--- a/stan/math/rev/functor/integrate_ode_adams.hpp
+++ b/stan/math/rev/functor/integrate_ode_adams.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/functor/ode_adams.hpp>
+#include <stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp>
 #include <ostream>
 #include <vector>
 

From 27d4f4909ff493c3a0662053c2ac01d8911f4c2c Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Tue, 23 Jun 2020 14:45:54 -0400
Subject: [PATCH 139/189] Added eval statement to handle `value_of` expressions
 (design-doc #19)

---
 stan/math/rev/functor/ode_store_sensitivities.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 725f5731a9e..71e532e71fe 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/prim/functor/ode_store_sensitivities.hpp>
 #include <stan/math/rev/core.hpp>
+#include <stan/math/rev/meta.hpp>
 #include <ostream>
 #include <vector>
 
@@ -32,8 +33,7 @@ namespace math {
  */
 template <typename F, typename T_y0_t0, typename T_t0, typename T_t,
           typename... Args,
-          typename
-          = require_any_autodiff_t<T_y0_t0, T_t0, T_t, scalar_type_t<Args>...>>
+          require_any_autodiff_t<T_y0_t0, T_t0, T_t, scalar_type_t<Args>...>* = nullptr>
 Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
     const F& f, const Eigen::VectorXd& coupled_state,
     const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0, const T_t0& t0,
@@ -53,7 +53,7 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
 
   Eigen::VectorXd f_y0_t0;
   if (is_var<T_t0>::value)
-    f_y0_t0 = f(value_of(t0), value_of(y0), msgs, value_of(args)...);
+    f_y0_t0 = f(value_of(t0), value_of(y0).eval(), msgs, value_of(args)...);
 
   for (size_t j = 0; j < N; j++) {
     const size_t total_vars = y0_vars + args_vars + t0_vars + t_vars;

From 1038387c296ce5029ee6f07f8143aad118338ec0 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Tue, 23 Jun 2020 18:49:37 +0000
Subject: [PATCH 140/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

---
 stan/math/rev/functor/ode_store_sensitivities.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 745b68b84cc..681323ab5ac 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -33,7 +33,8 @@ namespace math {
  */
 template <typename F, typename T_y0_t0, typename T_t0, typename T_t,
           typename... Args,
-          require_any_autodiff_t<T_y0_t0, T_t0, T_t, scalar_type_t<Args>...>* = nullptr>
+          require_any_autodiff_t<T_y0_t0, T_t0, T_t,
+                                 scalar_type_t<Args>...>* = nullptr>
 Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
     const F& f, const Eigen::VectorXd& coupled_state,
     const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0, const T_t0& t0,

From bae0be9b40d5816b68c1763b0a98fe42aed83fed Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Tue, 23 Jun 2020 16:22:47 -0400
Subject: [PATCH 141/189] Added tests for cvodes error prints, grad with no
 argument, and cleaned up comments (design doc #19)

---
 stan/math/rev/functor/coupled_ode_rhs.hpp     |  76 ---
 stan/math/rev/functor/cvodes_utils.hpp        |  14 +-
 .../rev/functor/ode_store_sensitivities.hpp   |   6 -
 .../functor/coupled_ode_observer_test.cpp     |  73 ---
 test/unit/math/rev/core/grad_test.cpp         |   6 +
 .../rev/functor/coupled_ode_observer_test.cpp | 371 --------------
 .../rev/functor/cvodes_ode_data_prim_test.cpp |  45 --
 .../rev/functor/cvodes_ode_data_rev_test.cpp  | 460 ------------------
 8 files changed, 12 insertions(+), 1039 deletions(-)
 delete mode 100644 stan/math/rev/functor/coupled_ode_rhs.hpp
 delete mode 100644 test/unit/math/prim/functor/coupled_ode_observer_test.cpp
 delete mode 100644 test/unit/math/rev/functor/coupled_ode_observer_test.cpp
 delete mode 100644 test/unit/math/rev/functor/cvodes_ode_data_prim_test.cpp
 delete mode 100644 test/unit/math/rev/functor/cvodes_ode_data_rev_test.cpp

diff --git a/stan/math/rev/functor/coupled_ode_rhs.hpp b/stan/math/rev/functor/coupled_ode_rhs.hpp
deleted file mode 100644
index 8ee6e728615..00000000000
--- a/stan/math/rev/functor/coupled_ode_rhs.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-#ifndef STAN_MATH_REV_FUNCTOR_COUPLED_ODE_RHS_HPP
-#define STAN_MATH_REV_FUNCTOR_COUPLED_ODE_RHS_HPP
-
-#include <stan/math/rev/fun/value_of.hpp>
-#include <stan/math/rev/core.hpp>
-#include <stan/math/prim/err.hpp>
-#include <ostream>
-#include <vector>
-
-namespace stan {
-namespace math {
-
-namespace internal {
-template <typename F, typename T_y, typename... Args>
-std::vector<double> coupled_ode_rhs(const F& f, double t,
-                                    const std::vector<T_y>& y,
-                                    std::ostream* msgs,
-                                    const Args&... args) const {
-  // Run nested autodiff in this scope
-  nested_rev_autodiff nested;
-
-  int N = y.size();
-  const size_t y_vars = count_vars(y);
-  const size_t args_vars = count_vars(args...);
-  std::vector<double> dz_dt(N + N * y_vars + N * args_vars);
-  const std::vector<var> y_vars(y.begin(), y.end());
-  std::tuple<decltype(deep_copy_vars(args))...> local_args_tuple(
-      deep_copy_vars(args)...);
-
-  std::vector<var> dy_dt_vars = apply(
-      [&](auto&&... args) { f_(t, y_vars, msgs_, args...); }, local_args_tuple);
-
-  check_size_match("coupled_ode_system", "dy_dt", dy_dt_vars.size(), "states",
-                   N);
-
-  for (size_t i = 0; i < N; ++i) {
-    dz_dt[i] = dy_dt_vars[i].val();
-    dy_dt_vars[i].grad();
-
-    for (size_t j = 0; j < y0_vars_; ++j) {
-      // orders derivatives by equation (i.e. if there are 2 eqns
-      // (y1, y2) and 2 parameters (a, b), dy_dt will be ordered as:
-      // dy1_dt, dy2_dt, dy1_da, dy2_da, dy1_db, dy2_db
-      double temp_deriv = 0;
-      const size_t offset = N + N * j;
-      for (size_t k = 0; k < N; k++) {
-        temp_deriv += z[N + N * j + k] * y_vars[k].adj();
-      }
-
-      dz_dt[N + N * j + i] = temp_deriv;
-    }
-
-    Eigen::VectorXd args_adjoints = Eigen::VectorXd::Zero(args_vars);
-    apply(
-        [&](auto&&... args) {
-          accumulate_adjoints(args_adjoints.data(), args...);
-        },
-        local_args_tuple);
-
-    for (size_t j = 0; j < args_vars; j++) {
-      double temp_deriv = args_adjoints(j);
-      for (size_t k = 0; k < N; k++) {
-        temp_deriv += z[N + N * y0_vars + N * j + k] * y_vars[k].adj();
-      }
-
-      dz_dt[N + N * y0_vars + N * j + i] = temp_deriv;
-    }
-
-    nested.set_zero_all_adjoints();
-  }
-}
-
-}  // namespace internal
-}  // namespace math
-}  // namespace stan
-#endif
diff --git a/stan/math/rev/functor/cvodes_utils.hpp b/stan/math/rev/functor/cvodes_utils.hpp
index 270e6c8dfd2..8b8f7056024 100644
--- a/stan/math/rev/functor/cvodes_utils.hpp
+++ b/stan/math/rev/functor/cvodes_utils.hpp
@@ -10,23 +10,21 @@
 namespace stan {
 namespace math {
 
-// no-op error handler to silence CVodes error output;  errors handled
-// directly by Stan
-extern "C" inline void cvodes_silent_err_handler(int error_code,
+extern "C" inline void cvodes_err_handler(int error_code,
                                                  const char* module,
                                                  const char* function,
                                                  char* msg, void* eh_data) {
-  // I found it handy to make this non-silent to debug CVODES while I set up
-  // the adjoint sensitivity. I'm keeping this here for now
-  std::cout << "Error " << msg << " (" << error_code << ") in " << module
-            << ", " << function << std::endl;
+  std::ostringstream msg1;
+  msg1 << msg << " Error code: ";
+
+  domain_error(module, function, error_code, msg1.str().c_str());
 }
 
 inline void cvodes_set_options(void* cvodes_mem, double rel_tol, double abs_tol,
                                // NOLINTNEXTLINE(runtime/int)
                                long int max_num_steps) {
   // forward CVode errors to noop error handler
-  CVodeSetErrHandlerFn(cvodes_mem, cvodes_silent_err_handler, nullptr);
+  CVodeSetErrHandlerFn(cvodes_mem, cvodes_err_handler, nullptr);
 
   // Initialize solver parameters
   check_flag_sundials(CVodeSStolerances(cvodes_mem, rel_tol, abs_tol),
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 745b68b84cc..e98894da96e 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -66,18 +66,14 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
     vari** varis_ptr = varis;
     double* partials_ptr = partials;
 
-    // iterate over parameters for each equation
     varis_ptr = save_varis(varis_ptr, y0);
     for (std::size_t k = 0; k < y0_vars; ++k) {
-      // *varis_ptr = y0[k].vi_;
       *partials_ptr = coupled_state(N + y0_vars * k + j);
       partials_ptr++;
     }
 
     varis_ptr = save_varis(varis_ptr, args...);
     for (std::size_t k = 0; k < args_vars; ++k) {
-      // dy[j]_dtheta[k]
-      // theta[k].vi_
       *partials_ptr = coupled_state(N + N * y0_vars + N * k + j);
       partials_ptr++;
     }
@@ -86,8 +82,6 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
     if (t0_vars > 0) {
       double dyt_dt0 = 0.0;
       for (std::size_t k = 0; k < y0_vars; ++k) {
-        // dy[j]_dtheta[k]
-        // theta[k].vi_
         dyt_dt0 += -f_y0_t0[k] * coupled_state(N + y0_vars * k + j);
       }
       *partials_ptr = dyt_dt0;
diff --git a/test/unit/math/prim/functor/coupled_ode_observer_test.cpp b/test/unit/math/prim/functor/coupled_ode_observer_test.cpp
deleted file mode 100644
index a241cfa2a10..00000000000
--- a/test/unit/math/prim/functor/coupled_ode_observer_test.cpp
+++ /dev/null
@@ -1,73 +0,0 @@
-#include <stan/math/prim.hpp>
-#include <gtest/gtest.h>
-#include <test/unit/util.hpp>
-#include <test/unit/math/prim/functor/harmonic_oscillator.hpp>
-#include <test/unit/math/prim/functor/mock_ode_functor.hpp>
-#include <test/unit/math/prim/functor/mock_throwing_ode_functor.hpp>
-#include <vector>
-#include <string>
-
-struct StanMathOde : public ::testing::Test {
-  std::stringstream msgs;
-  std::vector<double> x;
-  std::vector<int> x_int;
-};
-
-TEST_F(StanMathOde, observe_states_dddd) {
-  using stan::math::coupled_ode_system;
-
-  harm_osc_ode_fun harm_osc;
-
-  std::vector<double> y0(2);
-  std::vector<double> theta(1);
-
-  y0[0] = 1.0;
-  y0[1] = 0.5;
-  theta[0] = 0.15;
-
-  stan::math::coupled_ode_system<harm_osc_ode_fun, double, double>
-      coupled_system(harm_osc, y0, theta, x, x_int, &msgs);
-
-  std::vector<std::vector<double>> y;
-  double t0 = 0;
-  int T = 10;
-  std::vector<double> ts(T);
-  for (int t = 0; t < T; t++)
-    ts[t] = t;
-
-  stan::math::coupled_ode_observer<harm_osc_ode_fun, double, double, double,
-                                   double>
-      observer(harm_osc, y0, theta, t0, ts, x, x_int, &msgs, y);
-
-  int k = 0;
-  std::vector<std::vector<double>> ys_coupled(T);
-  for (int t = 0; t < T; t++) {
-    std::vector<double> coupled_state(coupled_system.size(), 0.0);
-    for (int n = 0; n < coupled_system.size(); n++)
-      coupled_state[n] = ++k;
-    ys_coupled[t] = coupled_state;
-    observer(coupled_state, ts[t]);
-  }
-
-  EXPECT_EQ(T, y.size());
-  for (int t = 0; t < T; t++)
-    EXPECT_EQ(2, y[t].size());
-
-  for (int t = 0; t < T; t++)
-    for (int n = 0; n < 2; n++)
-      EXPECT_FLOAT_EQ(ys_coupled[t][n], y[t][n])
-          << "(" << n << ", " << t << "): "
-          << "for (double, double) the coupled system is the base system";
-
-  // calling it once too often will fire an exception as the observer
-  // runs out of time states.
-  // note: the EXPECT_THROW_MSG calls the expression given twice which
-  // is why the time-state number is 11 by the time the comparison is
-  // done with the expected string (I would have expected 10 instead
-  // of 11).
-  std::string message
-      = "coupled_ode_observer: time-state number is 10, but must be less than "
-        "10";
-  std::vector<double> ys_coupled_0(coupled_system.size(), 0.0);
-  EXPECT_THROW_MSG(observer(ys_coupled_0, 20.), std::logic_error, message);
-}
diff --git a/test/unit/math/rev/core/grad_test.cpp b/test/unit/math/rev/core/grad_test.cpp
index 9446f8779f1..bf037794ad9 100644
--- a/test/unit/math/rev/core/grad_test.cpp
+++ b/test/unit/math/rev/core/grad_test.cpp
@@ -4,6 +4,12 @@
 #include <stan/math/rev/fun/sin.hpp>
 #include <vector>
 
+TEST(AgradRev, grad_no_argument) {
+  AVAR d = 2.0;
+  d = 2 * d;
+  stan::math::grad();
+}
+
 TEST(AgradRev, multiple_grads) {
   for (int i = 0; i < 100; ++i) {
     AVAR a = 2.0;
diff --git a/test/unit/math/rev/functor/coupled_ode_observer_test.cpp b/test/unit/math/rev/functor/coupled_ode_observer_test.cpp
deleted file mode 100644
index 26b29c78560..00000000000
--- a/test/unit/math/rev/functor/coupled_ode_observer_test.cpp
+++ /dev/null
@@ -1,371 +0,0 @@
-// mat is needed to get operands_and_partials working with
-// std::vector<var> edges needed in coupled_ode_observer
-#include <stan/math/rev.hpp>
-#include <test/unit/math/prim/functor/harmonic_oscillator.hpp>
-#include <test/unit/math/prim/functor/mock_ode_functor.hpp>
-#include <test/unit/util.hpp>
-#include <gtest/gtest.h>
-#include <vector>
-#include <string>
-
-struct StanRevOde : public ::testing::Test {
-  void TearDown() { stan::math::recover_memory(); }
-  std::stringstream msgs;
-  std::vector<double> x;
-  std::vector<int> x_int;
-};
-
-TEST_F(StanRevOde, observe_states_dvdd) {
-  using stan::math::coupled_ode_system;
-  using stan::math::var;
-
-  mock_ode_functor mock_ode;
-
-  std::vector<double> y0(2);
-  y0[0] = 1.0;
-  y0[1] = 0.5;
-
-  std::vector<var> theta(1);
-  theta[0] = 0.15;
-
-  coupled_ode_system<mock_ode_functor, double, var> coupled_system(
-      mock_ode, y0, theta, x, x_int, &msgs);
-
-  std::vector<std::vector<var>> y;
-  double t0 = 0;
-  int T = 10;
-  std::vector<double> ts(T);
-  for (int t = 0; t < T; t++)
-    ts[t] = t;
-
-  stan::math::coupled_ode_observer<mock_ode_functor, double, var, double,
-                                   double>
-      observer(mock_ode, y0, theta, t0, ts, x, x_int, &msgs, y);
-
-  size_t k = 0;
-  std::vector<std::vector<double>> ys_coupled(T);
-  for (size_t t = 0; t < T; t++) {
-    std::vector<double> coupled_state(coupled_system.size(), 0.0);
-    for (size_t n = 0; n < coupled_system.size(); n++)
-      coupled_state[n] = ++k;
-    ys_coupled[t] = coupled_state;
-    observer(coupled_state, ts[0]);
-  }
-
-  EXPECT_EQ(T, y.size());
-  for (size_t t = 0; t < T; t++)
-    EXPECT_EQ(2U, y[t].size());
-
-  for (size_t t = 0; t < T; t++) {
-    for (size_t n = 0; n < 2; n++)
-      EXPECT_FLOAT_EQ(ys_coupled[t][n], y[t][n].val());
-    for (size_t n = 0; n < 2; n++) {
-      y[t][n].grad();
-      EXPECT_FLOAT_EQ(ys_coupled[t][2 + n], theta[0].adj());
-      stan::math::set_zero_all_adjoints();
-    }
-  }
-}
-
-TEST_F(StanRevOde, observe_states_vddd) {
-  using stan::math::coupled_ode_system;
-  using stan::math::var;
-
-  mock_ode_functor mock_ode;
-
-  std::vector<var> y0(2);
-  std::vector<double> theta(1);
-
-  y0[0] = 1.0;
-  y0[1] = 0.5;
-  theta[0] = 0.15;
-
-  coupled_ode_system<mock_ode_functor, var, double> coupled_system(
-      mock_ode, y0, theta, x, x_int, &msgs);
-
-  std::vector<std::vector<var>> y;
-  double t0 = 0;
-  int T = 10;
-  std::vector<double> ts(T);
-  for (int t = 0; t < T; t++)
-    ts[t] = t;
-
-  stan::math::coupled_ode_observer<mock_ode_functor, var, double, double,
-                                   double>
-      observer(mock_ode, y0, theta, t0, ts, x, x_int, &msgs, y);
-
-  size_t k = 0;
-  std::vector<std::vector<double>> ys_coupled(T);
-  for (size_t t = 0; t < T; t++) {
-    std::vector<double> coupled_state(coupled_system.size(), 0.0);
-    for (size_t n = 0; n < coupled_system.size(); n++)
-      coupled_state[n] = ++k;
-    ys_coupled[t] = coupled_state;
-    observer(coupled_state, ts[t]);
-  }
-
-  EXPECT_EQ(T, y.size());
-  for (size_t t = 0; t < T; t++)
-    EXPECT_EQ(2U, y[t].size());
-
-  for (size_t t = 0; t < T; t++) {
-    for (size_t n = 0; n < 2; n++) {
-      EXPECT_FLOAT_EQ(ys_coupled[t][n], y[t][n].val());
-    }
-    for (size_t n = 0; n < 2; n++) {
-      y[t][n].grad();
-      EXPECT_FLOAT_EQ(ys_coupled[t][2 + n], y0[0].adj());
-      EXPECT_FLOAT_EQ(ys_coupled[t][2 + 2 + n], y0[1].adj());
-      stan::math::set_zero_all_adjoints();
-    }
-  }
-}
-
-TEST_F(StanRevOde, observe_states_vvdd) {
-  using stan::math::coupled_ode_system;
-  using stan::math::var;
-
-  harm_osc_ode_fun harm_osc;
-
-  std::vector<var> y0(2);
-  std::vector<var> theta(1);
-
-  y0[0] = 1.0;
-  y0[1] = 0.5;
-  theta[0] = 0.15;
-
-  coupled_ode_system<harm_osc_ode_fun, var, var> coupled_system(
-      harm_osc, y0, theta, x, x_int, &msgs);
-
-  std::vector<std::vector<var>> y;
-  double t0 = 0;
-  int T = 10;
-  std::vector<double> ts(T);
-  for (int t = 0; t < T; t++)
-    ts[t] = t;
-
-  stan::math::coupled_ode_observer<harm_osc_ode_fun, var, var, double, double>
-      observer(harm_osc, y0, theta, t0, ts, x, x_int, &msgs, y);
-
-  size_t k = 0;
-  std::vector<std::vector<double>> ys_coupled(T);
-  for (size_t t = 0; t < T; t++) {
-    std::vector<double> coupled_state(coupled_system.size(), 0.0);
-    for (size_t n = 0; n < coupled_system.size(); n++)
-      coupled_state[n] = ++k;
-    ys_coupled[t] = coupled_state;
-    observer(coupled_state, ts[t]);
-  }
-
-  EXPECT_EQ(T, y.size());
-  for (size_t t = 0; t < T; t++)
-    EXPECT_EQ(2U, y[t].size());
-
-  for (size_t t = 0; t < T; t++) {
-    for (size_t n = 0; n < 2; n++)
-      EXPECT_FLOAT_EQ(ys_coupled[t][n], y[t][n].val());
-
-    for (size_t n = 0; n < 2; n++) {
-      y[t][n].grad();
-      EXPECT_FLOAT_EQ(ys_coupled[t][2 + n], y0[0].adj());
-      EXPECT_FLOAT_EQ(ys_coupled[t][2 + 2 + n], y0[1].adj());
-      EXPECT_FLOAT_EQ(ys_coupled[t][2 + 2 * 2 + n], theta[0].adj());
-      stan::math::set_zero_all_adjoints();
-    }
-  }
-}
-
-TEST_F(StanRevOde, observe_states_ddvd) {
-  using stan::math::coupled_ode_system;
-  using stan::math::var;
-
-  mock_ode_functor mock_ode;
-
-  std::vector<double> y0(2);
-  y0[0] = 1.0;
-  y0[1] = 0.5;
-
-  std::vector<double> theta(1);
-  theta[0] = 0.15;
-
-  coupled_ode_system<mock_ode_functor, double, double> coupled_system(
-      mock_ode, y0, theta, x, x_int, &msgs);
-
-  std::vector<std::vector<var>> y;
-  var t0 = 0;
-  int T = 10;
-  std::vector<double> ts(T);
-  for (int t = 0; t < T; t++)
-    ts[t] = t;
-
-  stan::math::coupled_ode_observer<mock_ode_functor, double, double, var,
-                                   double>
-      observer(mock_ode, y0, theta, t0, ts, x, x_int, &msgs, y);
-
-  size_t k = 0;
-  std::vector<std::vector<double>> ys_coupled(T);
-  for (size_t t = 0; t < T; t++) {
-    std::vector<double> coupled_state(coupled_system.size(), 0.0);
-    for (size_t n = 0; n < coupled_system.size(); n++)
-      coupled_state[n] = ++k;
-    ys_coupled[t] = coupled_state;
-    observer(coupled_state, ts[0]);
-  }
-
-  EXPECT_EQ(T, y.size());
-  for (size_t t = 0; t < T; t++)
-    EXPECT_EQ(2U, y[t].size());
-
-  for (size_t t = 0; t < T; t++) {
-    for (size_t n = 0; n < 2; n++)
-      EXPECT_FLOAT_EQ(ys_coupled[t][n], y[t][n].val());
-    for (size_t n = 0; n < 2; n++) {
-      y[t][n].grad();
-      EXPECT_FLOAT_EQ(-y0[n], t0.adj());
-      stan::math::set_zero_all_adjoints();
-    }
-  }
-}
-
-TEST_F(StanRevOde, observe_states_dddv) {
-  using stan::math::coupled_ode_system;
-  using stan::math::var;
-
-  harm_osc_ode_fun harm_osc;
-
-  std::vector<double> y0(2);
-  std::vector<double> theta(1);
-
-  y0[0] = 1.0;
-  y0[1] = 0.5;
-  theta[0] = 0.15;
-
-  coupled_ode_system<harm_osc_ode_fun, double, double> coupled_system(
-      harm_osc, y0, theta, x, x_int, &msgs);
-
-  std::vector<std::vector<var>> y;
-  double t0 = 0;
-  int T = 10;
-  std::vector<var> ts(T);
-  for (int t = 0; t < T; t++)
-    ts[t] = t;
-
-  stan::math::coupled_ode_observer<harm_osc_ode_fun, double, double, double,
-                                   var>
-      observer(harm_osc, y0, theta, t0, ts, x, x_int, &msgs, y);
-
-  size_t k = 0;
-  std::vector<std::vector<double>> ys_coupled(T);
-  for (size_t t = 0; t < T; t++) {
-    std::vector<double> coupled_state(coupled_system.size(), 0.0);
-    for (size_t n = 0; n < coupled_system.size(); n++)
-      coupled_state[n] = ++k;
-    ys_coupled[t] = coupled_state;
-    observer(coupled_state, value_of(ts[t]));
-  }
-
-  EXPECT_EQ(T, y.size());
-  for (size_t t = 0; t < T; t++)
-    EXPECT_EQ(2U, y[t].size());
-
-  for (size_t t = 0; t < T; t++) {
-    for (size_t n = 0; n < 2; n++)
-      EXPECT_FLOAT_EQ(ys_coupled[t][n], y[t][n].val());
-
-    std::vector<double> yt(2);
-    yt[0] = ys_coupled[t][0];
-    yt[1] = ys_coupled[t][1];
-    std::vector<double> dy_dt
-        = harm_osc(value_of(ts[t]), yt, theta, x, x_int, &msgs);
-    for (size_t n = 0; n < 2; n++) {
-      y[t][n].grad();
-      EXPECT_FLOAT_EQ(ts[t].adj(), dy_dt[n]);
-      stan::math::set_zero_all_adjoints();
-    }
-  }
-
-  // trigger wrong size error by starting with a too large initial
-  // state which will cause the observer to trigger a size mismatch
-  y0.push_back(3);
-  stan::math::coupled_ode_observer<harm_osc_ode_fun, double, double, double,
-                                   var>
-      throwing_observer(harm_osc, y0, theta, t0, ts, x, x_int, &msgs, y);
-
-  // this one will throw
-  std::string message = "this function was called with inconsistent state";
-  EXPECT_THROW_MSG(
-      (throwing_observer(std::vector<double>(coupled_system.size(), 0.0), 0)),
-      std::logic_error, message);
-}
-
-TEST_F(StanRevOde, observe_states_ddvd_error) {
-  using stan::math::coupled_ode_system;
-  using stan::math::var;
-
-  harm_osc_ode_wrong_size_1_fun harm_osc1;
-  harm_osc_ode_fun harm_osc2;
-
-  std::vector<double> y0(2);
-  std::vector<double> theta(1);
-
-  y0[0] = 1.0;
-  y0[1] = 0.5;
-  theta[0] = 0.15;
-
-  std::vector<std::vector<var>> y;
-  var t0v = 0;
-  int T = 10;
-  std::vector<double> tsd(T);
-  for (int t = 0; t < T; t++) {
-    tsd[t] = t;
-  }
-
-  EXPECT_THROW_MSG(
-      (stan::math::coupled_ode_observer<harm_osc_ode_wrong_size_1_fun, double,
-                                        double, var, double>(
-          harm_osc1, y0, theta, t0v, tsd, x, x_int, &msgs, y)),
-      std::invalid_argument,
-      std::string(
-          "coupled_ode_observer: dy_dt (3) and states (2) must match in size"));
-
-  EXPECT_NO_THROW((stan::math::coupled_ode_observer<harm_osc_ode_fun, double,
-                                                    double, var, double>(
-      harm_osc2, y0, theta, t0v, tsd, x, x_int, &msgs, y)));
-}
-
-TEST_F(StanRevOde, observe_states_dddv_error) {
-  using stan::math::coupled_ode_system;
-  using stan::math::var;
-
-  harm_osc_ode_wrong_size_1_fun harm_osc1;
-  harm_osc_ode_fun harm_osc2;
-
-  std::vector<double> y0(2);
-  std::vector<double> theta(1);
-
-  y0[0] = 1.0;
-  y0[1] = 0.5;
-  theta[0] = 0.15;
-
-  std::vector<std::vector<var>> y;
-  double t0d = 0;
-  int T = 10;
-  std::vector<var> tsv(T);
-  for (int t = 0; t < T; t++) {
-    tsv[t] = t;
-  }
-
-  stan::math::coupled_ode_observer<harm_osc_ode_wrong_size_1_fun, double,
-                                   double, double, var>
-      throwing_observer(harm_osc1, y0, theta, t0d, tsv, x, x_int, &msgs, y);
-
-  stan::math::coupled_ode_observer<harm_osc_ode_fun, double, double, double,
-                                   var>
-      observer(harm_osc2, y0, theta, t0d, tsv, x, x_int, &msgs, y);
-
-  EXPECT_THROW_MSG(
-      (throwing_observer(std::vector<double>(2), 0)), std::invalid_argument,
-      std::string(
-          "coupled_ode_observer: dy_dt (3) and states (2) must match in size"));
-  EXPECT_NO_THROW((observer(std::vector<double>(2), 0)));
-}
diff --git a/test/unit/math/rev/functor/cvodes_ode_data_prim_test.cpp b/test/unit/math/rev/functor/cvodes_ode_data_prim_test.cpp
deleted file mode 100644
index 2bfe93e4555..00000000000
--- a/test/unit/math/rev/functor/cvodes_ode_data_prim_test.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-#include <stan/math/rev.hpp>
-#include <gtest/gtest.h>
-#include <test/unit/util.hpp>
-#include <test/unit/math/prim/functor/harmonic_oscillator.hpp>
-#include <test/unit/math/prim/functor/mock_ode_functor.hpp>
-#include <test/unit/math/prim/functor/mock_throwing_ode_functor.hpp>
-#include <string>
-#include <vector>
-
-struct StanMathOdeCVode : public ::testing::Test {
-  void SetUp() {
-    stan::math::recover_memory();
-    t0 = 0;
-  }
-  std::stringstream msgs;
-  std::vector<double> x;
-  std::vector<int> x_int;
-  double t0;
-};
-TEST_F(StanMathOdeCVode, recover_exception) {
-  using stan::math::cvodes_ode_data;
-  std::string message = "ode throws";
-
-  const int N = 3;
-  const int M = 4;
-
-  mock_throwing_ode_functor<std::logic_error> throwing_ode(message);
-
-  std::vector<double> y0_d(N, 0.0);
-  std::vector<double> theta_v(M, 0.0);
-
-  cvodes_ode_data<mock_throwing_ode_functor<std::logic_error>, double, double>
-      ode_data_dd(throwing_ode, y0_d, theta_v, x, x_int, &msgs);
-
-  std::vector<double> y(3, 0);
-  std::vector<double> dy_dt(3, 0);
-
-  N_Vector nv_y = N_VMake_Serial(N, &y[0]);
-  N_Vector nv_dy_dt = N_VMake_Serial(N, &dy_dt[0]);
-
-  double t = 10;
-
-  EXPECT_THROW_MSG(ode_data_dd.cv_rhs(t, nv_y, nv_dy_dt, &ode_data_dd),
-                   std::logic_error, message);
-}
diff --git a/test/unit/math/rev/functor/cvodes_ode_data_rev_test.cpp b/test/unit/math/rev/functor/cvodes_ode_data_rev_test.cpp
deleted file mode 100644
index 20fe29d8700..00000000000
--- a/test/unit/math/rev/functor/cvodes_ode_data_rev_test.cpp
+++ /dev/null
@@ -1,460 +0,0 @@
-#include <stan/math/rev.hpp>
-#include <gtest/gtest.h>
-#include <test/unit/util.hpp>
-#include <test/unit/math/prim/functor/harmonic_oscillator.hpp>
-#include <test/unit/math/prim/functor/mock_ode_functor.hpp>
-#include <test/unit/math/prim/functor/mock_throwing_ode_functor.hpp>
-#include <string>
-#include <algorithm>
-#include <vector>
-
-struct StanMathRevOdeCVode : public ::testing::Test {
-  void SetUp() {
-    stan::math::recover_memory();
-    t0 = 0;
-  }
-  std::stringstream msgs;
-  std::vector<double> x;
-  std::vector<int> x_int;
-  double t0;
-  N_Vector tmp1;
-  N_Vector tmp2;
-};
-
-// helper object to initialize data structures which we can pass into
-// the cvodes integrator object
-struct cvodes2coupled {
-  const size_t N_;
-  const size_t S_;
-  std::vector<double> state_;
-  std::vector<double> state_dot_;
-  double* p_state_;
-  double* p_state_dot_;
-  N_Vector cvode_state_;
-  N_Vector cvode_state_dot_;
-  N_Vector* cvode_state_sens_;
-  N_Vector* cvode_state_sens_dot_;
-
-  cvodes2coupled(const size_t N, const size_t S)
-      : N_(N),
-        S_(S),
-        state_(N, 0),
-        state_dot_(N, 0),
-        p_state_(&state_[0]),
-        p_state_dot_(&state_dot_[0]),
-        cvode_state_(N_VMake_Serial(N_, &state_[0])),
-        cvode_state_dot_(N_VMake_Serial(N_, &state_dot_[0])) {
-    if (S_ > 0) {
-      cvode_state_sens_ = N_VCloneVectorArray_Serial(S_, cvode_state_);
-      cvode_state_sens_dot_ = N_VCloneVectorArray_Serial(S_, cvode_state_);
-
-      for (size_t s = 0; s < S_; s++)
-        N_VConst(RCONST(0.0), cvode_state_sens_[s]);
-      for (size_t s = 0; s < S_; s++)
-        N_VConst(RCONST(0.0), cvode_state_sens_dot_[s]);
-    }
-  }
-
-  ~cvodes2coupled() {
-    // N_VDestroy_Serial should noop because
-    // N_VMake_Serial sets own_data to false
-    N_VDestroy_Serial(cvode_state_);
-    if (S_ > 0) {
-      N_VDestroyVectorArray_Serial(cvode_state_sens_, S_);
-      N_VDestroyVectorArray_Serial(cvode_state_sens_dot_, S_);
-    }
-  }
-
-  std::vector<double> get_coupled_state() const {
-    std::vector<double> y_coupled(N_ + N_ * S_, 0);
-
-    std::copy(state_.begin(), state_.end(), y_coupled.begin());
-
-    for (size_t s = 0; s < S_; s++) {
-      for (size_t n = 0; n < N_; n++) {
-        y_coupled[N_ + s * N_ + n] = NV_Ith_S(cvode_state_sens_[s], n);
-      }
-    }
-
-    return (y_coupled);
-  }
-
-  std::vector<double> get_coupled_state_dot() const {
-    std::vector<double> y_coupled_dot(N_ + N_ * S_, 0);
-
-    std::copy(state_dot_.begin(), state_dot_.end(), y_coupled_dot.begin());
-
-    for (size_t s = 0; s < S_; s++) {
-      for (size_t n = 0; n < N_; n++) {
-        y_coupled_dot[N_ + s * N_ + n] = NV_Ith_S(cvode_state_sens_dot_[s], n);
-      }
-    }
-
-    return (y_coupled_dot);
-  }
-};
-
-// ******************** DV ****************************
-TEST_F(StanMathRevOdeCVode, cvodes_ode_data_dv) {
-  using stan::math::cvodes_ode_data;
-
-  harm_osc_ode_fun harm_osc;
-
-  const size_t N = 2;
-  const int M = 1;
-  const size_t S = 1;
-
-  std::vector<stan::math::var> theta;
-  std::vector<double> y0;
-
-  double gamma(0.15);
-  t0 = 0;
-
-  theta.push_back(gamma);
-  y0.push_back(1.0);
-  y0.push_back(0.5);
-
-  cvodes_ode_data<harm_osc_ode_fun, double, stan::math::var> ode_data_dv(
-      harm_osc, y0, theta, x, x_int, &msgs);
-
-  cvodes2coupled nvec(N, S);
-
-  nvec.state_[0] = 1.0;
-  nvec.state_[1] = 0.5;
-  NV_Ith_S(nvec.cvode_state_sens_[0], 0) = 1.0;
-  NV_Ith_S(nvec.cvode_state_sens_[0], 1) = 2.0;
-
-  ode_data_dv.cv_rhs(t0, nvec.cvode_state_, nvec.cvode_state_dot_,
-                     &ode_data_dv);
-
-  ode_data_dv.cv_rhs_sens(M, t0, nvec.cvode_state_, nvec.cvode_state_dot_,
-                          nvec.cvode_state_sens_, nvec.cvode_state_sens_dot_,
-                          &ode_data_dv, tmp1, tmp2);
-
-  std::vector<double> dy_dt_coupled = nvec.get_coupled_state_dot();
-
-  EXPECT_FLOAT_EQ(0.5, dy_dt_coupled[0]);
-  EXPECT_FLOAT_EQ(-1.075, dy_dt_coupled[1]);
-  EXPECT_FLOAT_EQ(2, dy_dt_coupled[2]);
-  EXPECT_FLOAT_EQ(-1.8, dy_dt_coupled[3]);
-}
-TEST_F(StanMathRevOdeCVode, memory_recovery_dv) {
-  using stan::math::cvodes_ode_data;
-  using stan::math::var;
-  mock_ode_functor base_ode;
-
-  const size_t N = 3;
-  const size_t M = 4;
-  const size_t S = M;
-
-  std::vector<double> y0_d(N, 0.0);
-  std::vector<var> theta(M, 0.0);
-
-  cvodes_ode_data<mock_ode_functor, double, var> ode_data_dv(
-      base_ode, y0_d, theta, x, x_int, &msgs);
-
-  // std::vector<double> y(3, 0);
-  // std::vector<double> dy_dt(3, 0);
-  double t = 10;
-
-  cvodes2coupled nvec(N, S);
-
-  EXPECT_TRUE(stan::math::empty_nested());
-  EXPECT_NO_THROW(ode_data_dv.cv_rhs(t, nvec.cvode_state_,
-                                     nvec.cvode_state_dot_, &ode_data_dv));
-
-  EXPECT_NO_THROW(ode_data_dv.cv_rhs_sens(
-      static_cast<int>(M), t, nvec.cvode_state_, nvec.cvode_state_dot_,
-      nvec.cvode_state_sens_, nvec.cvode_state_sens_dot_, &ode_data_dv, tmp1,
-      tmp2));
-  EXPECT_TRUE(stan::math::empty_nested());
-}
-
-TEST_F(StanMathRevOdeCVode, memory_recovery_exception_dv) {
-  using stan::math::cvodes_ode_data;
-  using stan::math::var;
-  std::string message = "ode throws";
-
-  const size_t N = 3;
-  const size_t M = 4;
-  const size_t S = M;
-
-  for (size_t n = 0; n < N + 1; n++) {
-    std::stringstream scoped_message;
-    scoped_message << "iteration " << n;
-    SCOPED_TRACE(scoped_message.str());
-    mock_throwing_ode_functor<std::logic_error> throwing_ode(message, 1);
-
-    std::vector<double> y0_d(N, 0.0);
-    std::vector<var> theta(M, 0.0);
-
-    cvodes_ode_data<mock_throwing_ode_functor<std::logic_error>, double, var>
-        ode_data_dv(throwing_ode, y0_d, theta, x, x_int, &msgs);
-
-    std::vector<double> y(3, 0);
-    std::vector<double> dy_dt(3, 0);
-    double t = 10;
-
-    cvodes2coupled nvec(N, S);
-
-    EXPECT_TRUE(stan::math::empty_nested());
-    EXPECT_THROW_MSG(ode_data_dv.cv_rhs(t, nvec.cvode_state_,
-                                        nvec.cvode_state_dot_, &ode_data_dv),
-                     std::logic_error, message);
-    EXPECT_TRUE(stan::math::empty_nested());
-  }
-}
-
-// ******************** VD ****************************
-
-TEST_F(StanMathRevOdeCVode, cvodes_ode_data_vd) {
-  using stan::math::cvodes_ode_data;
-
-  harm_osc_ode_fun harm_osc;
-
-  const size_t N = 2;
-  const int M = 1;
-  const size_t S = N;
-
-  std::vector<double> theta;
-  std::vector<stan::math::var> y0_var;
-  std::vector<double> y0_d;
-  double t0;
-
-  double gamma(0.15);
-  t0 = 0;
-
-  theta.push_back(gamma);
-
-  // note: here the old test was inconsistent in that coupled_y0[0]
-  // and coupled_y0[1] should have been set to 0 instead.
-
-  // coupled_y0.push_back(1.0);
-  // coupled_y0.push_back(0.5);
-  // coupled_y0.push_back(1.0);
-  // coupled_y0.push_back(3.0);
-  // coupled_y0.push_back(2.0);
-  // coupled_y0.push_back(5.0);
-
-  y0_var.push_back(1.0);
-  y0_var.push_back(0.5);
-  y0_d.push_back(1.0);
-  y0_d.push_back(0.5);
-
-  cvodes_ode_data<harm_osc_ode_fun, stan::math::var, double> ode_data_vd(
-      harm_osc, y0_var, theta, x, x_int, &msgs);
-
-  cvodes2coupled nvec(N, S);
-
-  // nvec.state_[0] = 2*y0_d[0]; // use this to match old expectation
-  // nvec.state_[1] = 2*y0_d[1]; // use this to match old expectation
-  nvec.state_[0] = y0_d[0];
-  nvec.state_[1] = y0_d[1];
-  NV_Ith_S(nvec.cvode_state_sens_[0], 0) = 1.0 + 1.0;
-  NV_Ith_S(nvec.cvode_state_sens_[0], 1) = 3.0;
-  NV_Ith_S(nvec.cvode_state_sens_[1], 0) = 2.0;
-  NV_Ith_S(nvec.cvode_state_sens_[1], 1) = 5.0 + 1.0;
-
-  ode_data_vd.cv_rhs(t0, nvec.cvode_state_, nvec.cvode_state_dot_,
-                     &ode_data_vd);
-
-  ode_data_vd.cv_rhs_sens(M, t0, nvec.cvode_state_, nvec.cvode_state_dot_,
-                          nvec.cvode_state_sens_, nvec.cvode_state_sens_dot_,
-                          &ode_data_vd, tmp1, tmp2);
-
-  std::vector<double> dy_dt_coupled = nvec.get_coupled_state_dot();
-
-  // EXPECT_FLOAT_EQ(1.0, dy_dt_coupled[0]); // old expectation
-  // EXPECT_FLOAT_EQ(-2.0 - 0.15 * 1.0, dy_dt_coupled[1]); // old expectation
-  EXPECT_FLOAT_EQ(0.5, dy_dt_coupled[0]);
-  EXPECT_FLOAT_EQ(-1.0 - 0.15 * 0.5, dy_dt_coupled[1]);
-  EXPECT_FLOAT_EQ(0 + 1.0 * 0 + 3.0 * 1 + 0, dy_dt_coupled[2]);
-  EXPECT_FLOAT_EQ(-1.0 - 1.0 * 1.0 - 0.15 * 3.0, dy_dt_coupled[3]);
-  EXPECT_FLOAT_EQ(1.0 + 2.0 * 0 + 5.0 * 1.0, dy_dt_coupled[4]);
-  EXPECT_FLOAT_EQ(-0.15 - 1.0 * 2.0 - 0.15 * 5.0, dy_dt_coupled[5]);
-}
-TEST_F(StanMathRevOdeCVode, memory_recovery_vd) {
-  using stan::math::cvodes_ode_data;
-  using stan::math::var;
-  mock_ode_functor base_ode;
-
-  const size_t N = 3;
-  const size_t M = 4;
-  const size_t S = N;
-
-  std::vector<var> y0_v(N, 0.0);
-  std::vector<double> theta_d(M, 0.0);
-
-  cvodes_ode_data<mock_ode_functor, var, double> ode_data_vd(
-      base_ode, y0_v, theta_d, x, x_int, &msgs);
-
-  // std::vector<double> y(3, 0);
-  // std::vector<double> dy_dt(3, 0);
-  double t = 10;
-
-  cvodes2coupled nvec(N, S);
-
-  EXPECT_TRUE(stan::math::empty_nested());
-  EXPECT_NO_THROW(ode_data_vd.cv_rhs(t, nvec.cvode_state_,
-                                     nvec.cvode_state_dot_, &ode_data_vd));
-
-  EXPECT_NO_THROW(ode_data_vd.cv_rhs_sens(
-      static_cast<int>(M), t, nvec.cvode_state_, nvec.cvode_state_dot_,
-      nvec.cvode_state_sens_, nvec.cvode_state_sens_dot_, &ode_data_vd, tmp1,
-      tmp2));
-  EXPECT_TRUE(stan::math::empty_nested());
-}
-
-TEST_F(StanMathRevOdeCVode, memory_recovery_exception_vd) {
-  using stan::math::cvodes_ode_data;
-  using stan::math::var;
-  std::string message = "ode throws";
-
-  const size_t N = 3;
-  const size_t M = 4;
-  const size_t S = N;
-  for (size_t n = 0; n < N + 1; n++) {
-    std::stringstream scoped_message;
-    scoped_message << "iteration " << n;
-    SCOPED_TRACE(scoped_message.str());
-    mock_throwing_ode_functor<std::logic_error> throwing_ode(message, 1);
-
-    std::vector<var> y0_v(N, 0.0);
-    std::vector<double> theta_d(M, 0.0);
-
-    cvodes_ode_data<mock_throwing_ode_functor<std::logic_error>, var, double>
-        ode_data_vd(throwing_ode, y0_v, theta_d, x, x_int, &msgs);
-
-    double t = 10;
-
-    cvodes2coupled nvec(N, S);
-
-    EXPECT_TRUE(stan::math::empty_nested());
-    EXPECT_THROW_MSG(ode_data_vd.cv_rhs(t, nvec.cvode_state_,
-                                        nvec.cvode_state_dot_, &ode_data_vd),
-                     std::logic_error, message);
-    EXPECT_TRUE(stan::math::empty_nested());
-  }
-}
-
-// ******************** VV ****************************
-
-TEST_F(StanMathRevOdeCVode, cvodes_ode_data_vv) {
-  using stan::math::cvodes_ode_data;
-  using stan::math::var;
-
-  const size_t N = 2;
-  const int M = 1;
-  const size_t S = 1 + 2;
-
-  std::vector<var> y0_v;
-  y0_v.push_back(1.0);
-  y0_v.push_back(0.5);
-
-  std::vector<var> theta_v;
-  theta_v.push_back(0.15);
-
-  harm_osc_ode_fun harm_osc;
-
-  cvodes_ode_data<harm_osc_ode_fun, stan::math::var, stan::math::var>
-      ode_data_vv(harm_osc, y0_v, theta_v, x, x_int, &msgs);
-
-  t0 = 0;
-
-  std::vector<double> y0_d(2);
-  y0_d[0] = 1.0;
-  y0_d[1] = 0.5;
-
-  std::vector<double> theta_d(1);
-  theta_d[0] = 0.15;
-
-  cvodes2coupled nvec(N, S);
-
-  nvec.state_ = y0_d;
-  NV_Ith_S(nvec.cvode_state_sens_[0], 0) = 1.0;
-  NV_Ith_S(nvec.cvode_state_sens_[0], 1) = 0.0;
-  NV_Ith_S(nvec.cvode_state_sens_[1], 0) = 0.0;
-  NV_Ith_S(nvec.cvode_state_sens_[1], 1) = 1.0;
-
-  ode_data_vv.cv_rhs(t0, nvec.cvode_state_, nvec.cvode_state_dot_,
-                     &ode_data_vv);
-
-  ode_data_vv.cv_rhs_sens(M, t0, nvec.cvode_state_, nvec.cvode_state_dot_,
-                          nvec.cvode_state_sens_, nvec.cvode_state_sens_dot_,
-                          &ode_data_vv, tmp1, tmp2);
-
-  std::vector<double> dy_dt_coupled = nvec.get_coupled_state_dot();
-
-  std::vector<double> dy_dt_base
-      = harm_osc(0.0, y0_d, theta_d, x, x_int, &msgs);
-
-  EXPECT_FLOAT_EQ(dy_dt_base[0], dy_dt_coupled[0]);
-  EXPECT_FLOAT_EQ(dy_dt_base[1], dy_dt_coupled[1]);
-  EXPECT_FLOAT_EQ(0, dy_dt_coupled[2]);
-  EXPECT_FLOAT_EQ(-1, dy_dt_coupled[3]);
-  EXPECT_FLOAT_EQ(1, dy_dt_coupled[4]);
-  EXPECT_FLOAT_EQ(-0.15, dy_dt_coupled[5]);
-  EXPECT_FLOAT_EQ(0, dy_dt_coupled[6]);
-  EXPECT_FLOAT_EQ(-0.5, dy_dt_coupled[7]);
-}
-TEST_F(StanMathRevOdeCVode, memory_recovery_vv) {
-  using stan::math::cvodes_ode_data;
-  using stan::math::var;
-  mock_ode_functor base_ode;
-
-  const size_t N = 3;
-  const size_t M = 4;
-  const size_t S = N + M;
-
-  std::vector<var> y0_v(N, 0.0);
-  std::vector<var> theta_v(M, 0.0);
-
-  cvodes_ode_data<mock_ode_functor, var, var> ode_data_vv(
-      base_ode, y0_v, theta_v, x, x_int, &msgs);
-
-  double t = 10;
-
-  cvodes2coupled nvec(N, S);
-
-  EXPECT_TRUE(stan::math::empty_nested());
-  EXPECT_NO_THROW(ode_data_vv.cv_rhs(t, nvec.cvode_state_,
-                                     nvec.cvode_state_dot_, &ode_data_vv));
-
-  EXPECT_NO_THROW(ode_data_vv.cv_rhs_sens(
-      static_cast<int>(M), t, nvec.cvode_state_, nvec.cvode_state_dot_,
-      nvec.cvode_state_sens_, nvec.cvode_state_sens_dot_, &ode_data_vv, tmp1,
-      tmp2));
-  EXPECT_TRUE(stan::math::empty_nested());
-}
-
-TEST_F(StanMathRevOdeCVode, memory_recovery_exception_vv) {
-  using stan::math::cvodes_ode_data;
-  using stan::math::var;
-  std::string message = "ode throws";
-
-  const size_t N = 3;
-  const size_t M = 4;
-  const size_t S = N + M;
-  for (size_t n = 0; n < N + 1; n++) {
-    std::stringstream scoped_message;
-    scoped_message << "iteration " << n;
-    SCOPED_TRACE(scoped_message.str());
-    mock_throwing_ode_functor<std::logic_error> throwing_ode(message, 1);
-
-    std::vector<var> y0_v(N, 0.0);
-    std::vector<var> theta_v(M, 0.0);
-
-    cvodes_ode_data<mock_throwing_ode_functor<std::logic_error>, var, var>
-        ode_data_vv(throwing_ode, y0_v, theta_v, x, x_int, &msgs);
-
-    double t = 10;
-
-    cvodes2coupled nvec(N, S);
-
-    EXPECT_TRUE(stan::math::empty_nested());
-    EXPECT_THROW_MSG(ode_data_vv.cv_rhs(t, nvec.cvode_state_,
-                                        nvec.cvode_state_dot_, &ode_data_vv),
-                     std::logic_error, message);
-    EXPECT_TRUE(stan::math::empty_nested());
-  }
-}

From 0eff931a3de3dd0e5f3466da8802ecfad19e4343 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Tue, 23 Jun 2020 16:24:26 -0400
Subject: [PATCH 142/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 stan/math/rev/functor/cvodes_utils.hpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/stan/math/rev/functor/cvodes_utils.hpp b/stan/math/rev/functor/cvodes_utils.hpp
index 8b8f7056024..8b82e52cd18 100644
--- a/stan/math/rev/functor/cvodes_utils.hpp
+++ b/stan/math/rev/functor/cvodes_utils.hpp
@@ -10,10 +10,9 @@
 namespace stan {
 namespace math {
 
-extern "C" inline void cvodes_err_handler(int error_code,
-                                                 const char* module,
-                                                 const char* function,
-                                                 char* msg, void* eh_data) {
+extern "C" inline void cvodes_err_handler(int error_code, const char* module,
+                                          const char* function, char* msg,
+                                          void* eh_data) {
   std::ostringstream msg1;
   msg1 << msg << " Error code: ";
 

From 9a10def6a8fdc7413949c4c4afec70c50cbc8ad5 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Wed, 24 Jun 2020 17:03:24 -0400
Subject: [PATCH 143/189] More optimizations to make the new ode interfaces
 fast (design-doc #19)

---
 stan/math/prim/functor/coupled_ode_system.hpp | 28 +++++-
 stan/math/prim/functor/ode_rk45.hpp           | 13 +--
 .../prim/functor/ode_store_sensitivities.hpp  | 12 ++-
 stan/math/rev/core/deep_copy_vars.hpp         |  4 +-
 stan/math/rev/core/save_varis.hpp             |  2 +-
 stan/math/rev/functor/coupled_ode_system.hpp  | 76 ++++++++++-----
 stan/math/rev/functor/cvodes_integrator.hpp   |  6 +-
 .../rev/functor/ode_store_sensitivities.hpp   | 92 ++++++++++---------
 8 files changed, 145 insertions(+), 88 deletions(-)

diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
index ceaae36b437..516f2868386 100644
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -85,13 +85,23 @@ struct coupled_ode_system_impl<true, F, T_initial, Args...> {
                           std::ostream* msgs, const Args&... args)
       : f_(f), y0_(y0), args_tuple_(args...), N_(y0.size()), msgs_(msgs) {}
 
-  void operator()(const Eigen::VectorXd& y, Eigen::VectorXd& dy_dt,
+  void operator()(const std::vector<double>& z,
+		  std::vector<double>& dy_dt,
                   double t) const {
-    dy_dt = apply([&](const Args&... args) { return f_(t, y, msgs_, args...); },
-                  args_tuple_);
+    Eigen::VectorXd y(N_);
+    for (size_t n = 0; n < N_; ++n)
+      y.coeffRef(n) = z[n];
+
+    dy_dt.resize(N_);
+
+    Eigen::VectorXd f_y_t =
+      apply([&](const Args&... args) { return f_(t, y, msgs_, args...); },
+	    args_tuple_);
 
     check_size_match("coupled_ode_system", "y", y.size(), "dy_dt",
-                     dy_dt.size());
+                     f_y_t.size());
+
+    Eigen::Map<Eigen::VectorXd>(dy_dt.data(), dy_dt.size()) = f_y_t;
   }
 
   /**
@@ -119,7 +129,15 @@ struct coupled_ode_system_impl<true, F, T_initial, Args...> {
    *   elements are all zero as these are the Jacobian wrt to the
    *   parameters at the initial time-point, which is zero.
    */
-  Eigen::VectorXd initial_state() const { return value_of(y0_); }
+  std::vector<double> initial_state() const {
+    std::vector<double> initial(size(), 0.0);
+
+    for (size_t i = 0; i < N_; i++) {
+      initial[i] = value_of(y0_(i));
+    }
+
+    return initial;
+  }
 };
 
 template <typename F, typename T_initial, typename... Args>
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index adb0e433152..ea10bbc6ee3 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -67,8 +67,8 @@ ode_rk45_tol(const F& f,
 
   using T_initial_or_t0 = return_type_t<T_initial, T_t0>;
 
-  Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1> y0 = y0_arg.unaryExpr(
-      [](const T_initial& val) { return T_initial_or_t0(val); });
+  Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1> y0 = y0_arg.
+    unaryExpr([](const T_initial& val) { return T_initial_or_t0(val); });
 
   check_finite("integrate_ode_rk45", "initial state", y0);
   check_finite("integrate_ode_rk45", "initial time", t0);
@@ -108,7 +108,7 @@ ode_rk45_tol(const F& f,
   // avoid recording of the initial state which is included by the
   // conventions of odeint in the output
   auto filtered_observer
-      = [&](const Eigen::VectorXd& coupled_state, double t) -> void {
+    = [&](const std::vector<double>& coupled_state, double t) -> void {
     if (!observer_initial_recorded) {
       observer_initial_recorded = true;
       return;
@@ -119,14 +119,15 @@ ode_rk45_tol(const F& f,
   };
 
   // the coupled system creates the coupled initial state
-  Eigen::VectorXd initial_coupled_state = coupled_system.initial_state();
+  std::vector<double> initial_coupled_state =
+    coupled_system.initial_state();
 
   const double step_size = 0.1;
   integrate_times(
       make_dense_output(
           absolute_tolerance, relative_tolerance,
-          runge_kutta_dopri5<Eigen::VectorXd, double, Eigen::VectorXd, double,
-                             vector_space_algebra>()),
+          runge_kutta_dopri5<std::vector<double>, double,
+	                     std::vector<double>, double>()),
       std::ref(coupled_system), initial_coupled_state, std::begin(ts_vec),
       std::end(ts_vec), step_size, filtered_observer,
       max_step_checker(max_num_steps));
diff --git a/stan/math/prim/functor/ode_store_sensitivities.hpp b/stan/math/prim/functor/ode_store_sensitivities.hpp
index cf5a5fb2b86..5155cbd47f9 100644
--- a/stan/math/prim/functor/ode_store_sensitivities.hpp
+++ b/stan/math/prim/functor/ode_store_sensitivities.hpp
@@ -27,11 +27,13 @@ template <
     typename F, typename T_y0_t0, typename T_t0, typename T_t, typename... Args,
     typename
     = require_all_arithmetic_t<T_y0_t0, T_t0, T_t, scalar_type_t<Args>...>>
-Eigen::VectorXd ode_store_sensitivities(
-    const F& f, const Eigen::VectorXd& coupled_state,
-    const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0, T_t0 t0, T_t t,
-    std::ostream* msgs, const Args&... args) {
-  return coupled_state.head(y0.size());
+Eigen::VectorXd ode_store_sensitivities(const F& f,
+					const std::vector<double>& coupled_state,
+					const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0,
+					T_t0 t0, T_t t,
+					std::ostream* msgs, const Args&... args) {
+  return Eigen::Map<const Eigen::VectorXd>(coupled_state.data(),
+					   coupled_state.size());
 }
 
 }  // namespace math
diff --git a/stan/math/rev/core/deep_copy_vars.hpp b/stan/math/rev/core/deep_copy_vars.hpp
index 5eb1b3d8542..70dc3b66e99 100644
--- a/stan/math/rev/core/deep_copy_vars.hpp
+++ b/stan/math/rev/core/deep_copy_vars.hpp
@@ -20,8 +20,8 @@ namespace math {
  *  Otherwise it will be moved.
  */
 template <typename Arith, typename = require_arithmetic_t<scalar_type_t<Arith>>>
-inline decltype(auto) deep_copy_vars(Arith&& arg) {
-  return std::forward<Arith>(arg);
+inline const Arith& deep_copy_vars(const Arith& arg) {
+  return arg;
 }
 
 /**
diff --git a/stan/math/rev/core/save_varis.hpp b/stan/math/rev/core/save_varis.hpp
index d97e8a1a474..dfeefa71728 100644
--- a/stan/math/rev/core/save_varis.hpp
+++ b/stan/math/rev/core/save_varis.hpp
@@ -113,7 +113,7 @@ inline vari** save_varis(vari** dest, VecContainer&& x, Pargs&&... args) {
 template <typename EigT, require_eigen_vt<is_var, EigT>*, typename... Pargs>
 inline vari** save_varis(vari** dest, EigT&& x, Pargs&&... args) {
   for (int i = 0; i < x.size(); ++i) {
-    dest[i] = x(i).vi_;
+    dest[i] = x.coeffRef(i).vi_;
   }
   return save_varis(dest + x.size(), std::forward<Pargs>(args)...);
 }
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index a5370b37f9a..dc8d4339504 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -67,6 +67,7 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
   const F& f_;
   const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_;
   std::tuple<const Args&...> args_tuple_;
+  std::tuple<decltype(deep_copy_vars(std::declval<Args>()))...> local_args_tuple_;
   const size_t y0_vars_;
   const size_t args_vars_;
   const size_t N_;
@@ -90,13 +91,44 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
       : f_(f),
         y0_(y0),
         args_tuple_(args...),
+	local_args_tuple_(deep_copy_vars(args)...),
         y0_vars_(count_vars(y0_)),
         args_vars_(count_vars(args...)),
         N_(y0.size()),
         args_adjoints_(args_vars_),
         y_adjoints_(N_),
-        msgs_(msgs) {}
+        msgs_(msgs) {  
+  }
+
+  inline void zero_local_adjoints() {}
+  
+  template <typename T,
+	    typename... Pargs>
+  inline void zero_local_adjoints(T& x, Pargs&... args) {
+    zero_local_adjoints(args...);
+  }
+
+  template <typename... Pargs>
+  inline void zero_local_adjoints(var& x, Pargs&... args) {
+    x.vi_->set_zero_adjoint();
+    zero_local_adjoints(args...);
+  }
 
+  template <typename... Pargs>
+  inline void zero_local_adjoints(std::vector<var>& x, Pargs&... args) {
+    for(size_t i = 0; i < x.size(); ++i)
+      x[i].vi_->set_zero_adjoint();
+    zero_local_adjoints(args...);
+  }
+
+  template <int R, int C, typename... Pargs>
+  inline void zero_local_adjoints(Eigen::Matrix<var, R, C>& x,
+				  Pargs&... args) {
+    for(size_t i = 0; i < x.size(); ++i)
+      x.coeffRef(i).vi_->set_zero_adjoint();
+    zero_local_adjoints(args...);
+  }
+  
   /**
    * Calculates the derivative of the coupled ode system with respect
    * to time.
@@ -111,35 +143,33 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
    * @throw exception if the base ode function does not return the
    *    expected number of derivatives, N.
    */
-  void operator()(const Eigen::VectorXd& z, Eigen::VectorXd& dz_dt, double t) {
+  void operator()(const std::vector<double>& z,
+		  std::vector<double>& dz_dt, double t) {
     using std::vector;
 
     dz_dt.resize(size());
 
     // Run nested autodiff in this scope
     nested_rev_autodiff nested;
+    
+    /*auto local_args_tuple_ = apply([&](auto&&... args) {
+	return std::tuple<decltype(deep_copy_vars(args))...>(deep_copy_vars(args)...);
+	}, args_tuple_);*/
 
     Eigen::Matrix<var, Eigen::Dynamic, 1> y_vars(N_);
     for (size_t n = 0; n < N_; ++n)
-      y_vars(n) = z(n);
-
-    auto local_args_tuple = apply(
-        [&](auto&&... args) {
-          return std::tuple<decltype(deep_copy_vars(args))...>(
-              deep_copy_vars(args)...);
-        },
-        args_tuple_);
+      y_vars.coeffRef(n) = z[n];
 
     Eigen::Matrix<var, Eigen::Dynamic, 1> f_y_t_vars
         = apply([&](auto&&... args) { return f_(t, y_vars, msgs_, args...); },
-                local_args_tuple);
+                local_args_tuple_);
 
     check_size_match("coupled_ode_system", "dy_dt", f_y_t_vars.size(), "states",
                      N_);
 
     for (size_t i = 0; i < N_; ++i) {
-      dz_dt(i) = f_y_t_vars(i).val();
-      f_y_t_vars(i).grad();
+      dz_dt[i] = f_y_t_vars.coeffRef(i).val();
+      f_y_t_vars.coeffRef(i).grad();
 
       y_adjoints_ = y_vars.adj();
 
@@ -148,8 +178,12 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
           [&](auto&&... args) {
             accumulate_adjoints(args_adjoints_.data(), args...);
           },
-          local_args_tuple);
+          local_args_tuple_);
 
+      apply([&](auto&&... args) {
+	  zero_local_adjoints(args...);
+	}, local_args_tuple_);
+      
       nested.set_zero_all_adjoints();
 
       for (size_t j = 0; j < y0_vars_; ++j) {
@@ -158,16 +192,16 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
         // dy1_dt, dy2_dt, dy1_da, dy2_da, dy1_db, dy2_db
         double temp_deriv = 0.0;
         for (size_t k = 0; k < N_; ++k) {
-          temp_deriv += z[N_ + N_ * j + k] * y_adjoints_[k];
+          temp_deriv += z[N_ + N_ * j + k] * y_adjoints_.coeffRef(k);
         }
 
         dz_dt[N_ + N_ * j + i] = temp_deriv;
       }
 
       for (size_t j = 0; j < args_vars_; ++j) {
-        double temp_deriv = args_adjoints_[j];
+        double temp_deriv = args_adjoints_.coeffRef(j);
         for (size_t k = 0; k < N_; ++k) {
-          temp_deriv += z[N_ + N_ * y0_vars_ + N_ * j + k] * y_adjoints_[k];
+          temp_deriv += z[N_ + N_ * y0_vars_ + N_ * j + k] * y_adjoints_.coeffRef(k);
         }
 
         dz_dt[N_ + N_ * y0_vars_ + N_ * j + i] = temp_deriv;
@@ -200,13 +234,13 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
    *   elements are all zero as these are the Jacobian wrt to the
    *   parameters at the initial time-point, which is zero.
    */
-  Eigen::VectorXd initial_state() const {
-    Eigen::VectorXd initial = Eigen::VectorXd::Zero(size());
+  std::vector<double> initial_state() const {
+    std::vector<double> initial(size(), 0.0);
     for (size_t i = 0; i < N_; i++) {
-      initial(i) = value_of(y0_[i]);
+      initial[i] = value_of(y0_(i));
     }
     for (size_t i = 0; i < y0_vars_; i++) {
-      initial(N_ + i * N_ + i) = 1.0;
+      initial[N_ + i * N_ + i] = 1.0;
     }
     return initial;
   }
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 3cb74a6c17a..99fd4091ff8 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -53,7 +53,7 @@ class cvodes_integrator {
 
   coupled_ode_system<F, T_y0_t0, T_Args...> coupled_ode_;
 
-  Eigen::VectorXd coupled_state_;
+  std::vector<double> coupled_state_;
   N_Vector nv_state_;
   N_Vector* nv_state_sens_;
   SUNMatrix A_;
@@ -142,8 +142,8 @@ class cvodes_integrator {
    */
   inline void rhs_sens(double t, const double y[], N_Vector* yS,
                        N_Vector* ySdot) {
-    Eigen::VectorXd z(coupled_state_.size());
-    Eigen::VectorXd dz_dt;
+    std::vector<double> z(coupled_state_.size());
+    std::vector<double> dz_dt;
     std::copy(y, y + N_, z.data());
     for (std::size_t s = 0; s < y0_vars_ + args_vars_; s++) {
       std::copy(NV_DATA_S(yS[s]), NV_DATA_S(yS[s]) + N_,
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 8cc9b669dcc..675faeb2493 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -36,8 +36,10 @@ template <typename F, typename T_y0_t0, typename T_t0, typename T_t,
           require_any_autodiff_t<T_y0_t0, T_t0, T_t,
                                  scalar_type_t<Args>...>* = nullptr>
 Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
-    const F& f, const Eigen::VectorXd& coupled_state,
-    const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0, const T_t0& t0,
+    const F& f,
+    const std::vector<double>& coupled_state,
+    const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0,
+    const T_t0& t0,
     const T_t& t, std::ostream* msgs, const Args&... args) {
   const size_t N = y0.size();
   const size_t y0_vars = count_vars(y0);
@@ -46,7 +48,10 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
   const size_t t_vars = count_vars(t);
   Eigen::Matrix<var, Eigen::Dynamic, 1> yt(N);
 
-  Eigen::VectorXd y = coupled_state.head(N);
+  Eigen::VectorXd y(N);
+  for(size_t n = 0; n < N; ++n) {
+    y.coeffRef(n) = coupled_state[n];
+  }
 
   Eigen::VectorXd f_y_t;
   if (is_var<T_t>::value)
@@ -55,48 +60,45 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
   Eigen::VectorXd f_y0_t0;
   if (is_var<T_t0>::value)
     f_y0_t0 = f(value_of(t0), value_of(y0).eval(), msgs, value_of(args)...);
-
-  for (size_t j = 0; j < N; j++) {
-    const size_t total_vars = y0_vars + args_vars + t0_vars + t_vars;
-
-    vari** varis
-        = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
-    double* partials
-        = ChainableStack::instance_->memalloc_.alloc_array<double>(total_vars);
-
-    vari** varis_ptr = varis;
-    double* partials_ptr = partials;
-
-    varis_ptr = save_varis(varis_ptr, y0);
-    for (std::size_t k = 0; k < y0_vars; ++k) {
-      *partials_ptr = coupled_state(N + y0_vars * k + j);
-      partials_ptr++;
-    }
-
-    varis_ptr = save_varis(varis_ptr, args...);
-    for (std::size_t k = 0; k < args_vars; ++k) {
-      *partials_ptr = coupled_state(N + N * y0_vars + N * k + j);
-      partials_ptr++;
-    }
-
-    varis_ptr = save_varis(varis_ptr, t0);
-    if (t0_vars > 0) {
-      double dyt_dt0 = 0.0;
-      for (std::size_t k = 0; k < y0_vars; ++k) {
-        dyt_dt0 += -f_y0_t0[k] * coupled_state(N + y0_vars * k + j);
-      }
-      *partials_ptr = dyt_dt0;
-      partials_ptr++;
-    }
-
-    varis_ptr = save_varis(varis_ptr, t);
-    if (t_vars > 0) {
-      *partials_ptr = f_y_t[j];
-      partials_ptr++;
-    }
-
-    yt(j) = new precomputed_gradients_vari(y(j), total_vars, varis, partials);
-  }
+  
+  const size_t total_vars = y0_vars + args_vars + t0_vars + t_vars;
+
+  vari** varis
+    = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
+  double* partials
+    = ChainableStack::instance_->memalloc_.alloc_array<double>(N * total_vars);
+
+  vari** varis_ptr = varis;
+  varis_ptr = save_varis(varis_ptr, y0);
+  varis_ptr = save_varis(varis_ptr, args...);
+  varis_ptr = save_varis(varis_ptr, t0);
+  varis_ptr = save_varis(varis_ptr, t);
+
+   for (size_t j = 0; j < N; ++j) {
+     double* partials_j = partials + j * total_vars;
+     for (size_t k = 0; k < y0_vars; ++k) {
+       partials_j[k] = coupled_state[N + y0_vars * k + j];
+     }
+
+     for (size_t k = 0; k < args_vars; ++k) {
+       partials_j[y0_vars + k] = coupled_state[N + N * y0_vars + N * k + j];
+     }
+
+     if (t0_vars > 0) {
+       double dyt_dt0 = 0.0;
+       for (size_t k = 0; k < y0_vars; ++k) {
+	 dyt_dt0 += -f_y0_t0.coeffRef(k) * coupled_state[N + y0_vars * k + j];
+       }
+       partials_j[y0_vars + args_vars] = dyt_dt0;
+     }
+
+     if (t_vars > 0) {
+       partials_j[y0_vars + args_vars + t0_vars] = f_y_t.coeffRef(j);
+     }
+
+     yt(j) = new precomputed_gradients_vari(y(j), total_vars,
+					    varis, partials_j);
+   }
 
   return yt;
 }

From 18f5c2dcd9b4e90bdf575f5250d761b56b2ff71b Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Wed, 24 Jun 2020 17:29:01 -0400
Subject: [PATCH 144/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 stan/math/prim/functor/coupled_ode_system.hpp |  9 ++-
 stan/math/prim/functor/ode_rk45.hpp           | 16 ++---
 .../prim/functor/ode_store_sensitivities.hpp  | 11 ++--
 stan/math/rev/functor/coupled_ode_system.hpp  | 43 ++++++------
 .../rev/functor/ode_store_sensitivities.hpp   | 65 +++++++++----------
 5 files changed, 68 insertions(+), 76 deletions(-)

diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
index 516f2868386..a00b78bb333 100644
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -85,8 +85,7 @@ struct coupled_ode_system_impl<true, F, T_initial, Args...> {
                           std::ostream* msgs, const Args&... args)
       : f_(f), y0_(y0), args_tuple_(args...), N_(y0.size()), msgs_(msgs) {}
 
-  void operator()(const std::vector<double>& z,
-		  std::vector<double>& dy_dt,
+  void operator()(const std::vector<double>& z, std::vector<double>& dy_dt,
                   double t) const {
     Eigen::VectorXd y(N_);
     for (size_t n = 0; n < N_; ++n)
@@ -94,9 +93,9 @@ struct coupled_ode_system_impl<true, F, T_initial, Args...> {
 
     dy_dt.resize(N_);
 
-    Eigen::VectorXd f_y_t =
-      apply([&](const Args&... args) { return f_(t, y, msgs_, args...); },
-	    args_tuple_);
+    Eigen::VectorXd f_y_t
+        = apply([&](const Args&... args) { return f_(t, y, msgs_, args...); },
+                args_tuple_);
 
     check_size_match("coupled_ode_system", "y", y.size(), "dy_dt",
                      f_y_t.size());
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index ea10bbc6ee3..4614267a8bb 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -67,8 +67,8 @@ ode_rk45_tol(const F& f,
 
   using T_initial_or_t0 = return_type_t<T_initial, T_t0>;
 
-  Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1> y0 = y0_arg.
-    unaryExpr([](const T_initial& val) { return T_initial_or_t0(val); });
+  Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1> y0 = y0_arg.unaryExpr(
+      [](const T_initial& val) { return T_initial_or_t0(val); });
 
   check_finite("integrate_ode_rk45", "initial state", y0);
   check_finite("integrate_ode_rk45", "initial time", t0);
@@ -108,7 +108,7 @@ ode_rk45_tol(const F& f,
   // avoid recording of the initial state which is included by the
   // conventions of odeint in the output
   auto filtered_observer
-    = [&](const std::vector<double>& coupled_state, double t) -> void {
+      = [&](const std::vector<double>& coupled_state, double t) -> void {
     if (!observer_initial_recorded) {
       observer_initial_recorded = true;
       return;
@@ -119,15 +119,13 @@ ode_rk45_tol(const F& f,
   };
 
   // the coupled system creates the coupled initial state
-  std::vector<double> initial_coupled_state =
-    coupled_system.initial_state();
+  std::vector<double> initial_coupled_state = coupled_system.initial_state();
 
   const double step_size = 0.1;
   integrate_times(
-      make_dense_output(
-          absolute_tolerance, relative_tolerance,
-          runge_kutta_dopri5<std::vector<double>, double,
-	                     std::vector<double>, double>()),
+      make_dense_output(absolute_tolerance, relative_tolerance,
+                        runge_kutta_dopri5<std::vector<double>, double,
+                                           std::vector<double>, double>()),
       std::ref(coupled_system), initial_coupled_state, std::begin(ts_vec),
       std::end(ts_vec), step_size, filtered_observer,
       max_step_checker(max_num_steps));
diff --git a/stan/math/prim/functor/ode_store_sensitivities.hpp b/stan/math/prim/functor/ode_store_sensitivities.hpp
index 5155cbd47f9..bdab74da3be 100644
--- a/stan/math/prim/functor/ode_store_sensitivities.hpp
+++ b/stan/math/prim/functor/ode_store_sensitivities.hpp
@@ -27,13 +27,12 @@ template <
     typename F, typename T_y0_t0, typename T_t0, typename T_t, typename... Args,
     typename
     = require_all_arithmetic_t<T_y0_t0, T_t0, T_t, scalar_type_t<Args>...>>
-Eigen::VectorXd ode_store_sensitivities(const F& f,
-					const std::vector<double>& coupled_state,
-					const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0,
-					T_t0 t0, T_t t,
-					std::ostream* msgs, const Args&... args) {
+Eigen::VectorXd ode_store_sensitivities(
+    const F& f, const std::vector<double>& coupled_state,
+    const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0, T_t0 t0, T_t t,
+    std::ostream* msgs, const Args&... args) {
   return Eigen::Map<const Eigen::VectorXd>(coupled_state.data(),
-					   coupled_state.size());
+                                           coupled_state.size());
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index dc8d4339504..f4f1f4df9bd 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -67,7 +67,8 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
   const F& f_;
   const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_;
   std::tuple<const Args&...> args_tuple_;
-  std::tuple<decltype(deep_copy_vars(std::declval<Args>()))...> local_args_tuple_;
+  std::tuple<decltype(deep_copy_vars(std::declval<Args>()))...>
+      local_args_tuple_;
   const size_t y0_vars_;
   const size_t args_vars_;
   const size_t N_;
@@ -91,19 +92,17 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
       : f_(f),
         y0_(y0),
         args_tuple_(args...),
-	local_args_tuple_(deep_copy_vars(args)...),
+        local_args_tuple_(deep_copy_vars(args)...),
         y0_vars_(count_vars(y0_)),
         args_vars_(count_vars(args...)),
         N_(y0.size()),
         args_adjoints_(args_vars_),
         y_adjoints_(N_),
-        msgs_(msgs) {  
-  }
+        msgs_(msgs) {}
 
   inline void zero_local_adjoints() {}
-  
-  template <typename T,
-	    typename... Pargs>
+
+  template <typename T, typename... Pargs>
   inline void zero_local_adjoints(T& x, Pargs&... args) {
     zero_local_adjoints(args...);
   }
@@ -116,19 +115,18 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
 
   template <typename... Pargs>
   inline void zero_local_adjoints(std::vector<var>& x, Pargs&... args) {
-    for(size_t i = 0; i < x.size(); ++i)
+    for (size_t i = 0; i < x.size(); ++i)
       x[i].vi_->set_zero_adjoint();
     zero_local_adjoints(args...);
   }
 
   template <int R, int C, typename... Pargs>
-  inline void zero_local_adjoints(Eigen::Matrix<var, R, C>& x,
-				  Pargs&... args) {
-    for(size_t i = 0; i < x.size(); ++i)
+  inline void zero_local_adjoints(Eigen::Matrix<var, R, C>& x, Pargs&... args) {
+    for (size_t i = 0; i < x.size(); ++i)
       x.coeffRef(i).vi_->set_zero_adjoint();
     zero_local_adjoints(args...);
   }
-  
+
   /**
    * Calculates the derivative of the coupled ode system with respect
    * to time.
@@ -143,18 +141,19 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
    * @throw exception if the base ode function does not return the
    *    expected number of derivatives, N.
    */
-  void operator()(const std::vector<double>& z,
-		  std::vector<double>& dz_dt, double t) {
+  void operator()(const std::vector<double>& z, std::vector<double>& dz_dt,
+                  double t) {
     using std::vector;
 
     dz_dt.resize(size());
 
     // Run nested autodiff in this scope
     nested_rev_autodiff nested;
-    
+
     /*auto local_args_tuple_ = apply([&](auto&&... args) {
-	return std::tuple<decltype(deep_copy_vars(args))...>(deep_copy_vars(args)...);
-	}, args_tuple_);*/
+        return
+       std::tuple<decltype(deep_copy_vars(args))...>(deep_copy_vars(args)...);
+        }, args_tuple_);*/
 
     Eigen::Matrix<var, Eigen::Dynamic, 1> y_vars(N_);
     for (size_t n = 0; n < N_; ++n)
@@ -180,10 +179,9 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
           },
           local_args_tuple_);
 
-      apply([&](auto&&... args) {
-	  zero_local_adjoints(args...);
-	}, local_args_tuple_);
-      
+      apply([&](auto&&... args) { zero_local_adjoints(args...); },
+            local_args_tuple_);
+
       nested.set_zero_all_adjoints();
 
       for (size_t j = 0; j < y0_vars_; ++j) {
@@ -201,7 +199,8 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
       for (size_t j = 0; j < args_vars_; ++j) {
         double temp_deriv = args_adjoints_.coeffRef(j);
         for (size_t k = 0; k < N_; ++k) {
-          temp_deriv += z[N_ + N_ * y0_vars_ + N_ * j + k] * y_adjoints_.coeffRef(k);
+          temp_deriv
+              += z[N_ + N_ * y0_vars_ + N_ * j + k] * y_adjoints_.coeffRef(k);
         }
 
         dz_dt[N_ + N_ * y0_vars_ + N_ * j + i] = temp_deriv;
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 675faeb2493..e7cbdcb9215 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -36,10 +36,8 @@ template <typename F, typename T_y0_t0, typename T_t0, typename T_t,
           require_any_autodiff_t<T_y0_t0, T_t0, T_t,
                                  scalar_type_t<Args>...>* = nullptr>
 Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
-    const F& f,
-    const std::vector<double>& coupled_state,
-    const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0,
-    const T_t0& t0,
+    const F& f, const std::vector<double>& coupled_state,
+    const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0, const T_t0& t0,
     const T_t& t, std::ostream* msgs, const Args&... args) {
   const size_t N = y0.size();
   const size_t y0_vars = count_vars(y0);
@@ -49,7 +47,7 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
   Eigen::Matrix<var, Eigen::Dynamic, 1> yt(N);
 
   Eigen::VectorXd y(N);
-  for(size_t n = 0; n < N; ++n) {
+  for (size_t n = 0; n < N; ++n) {
     y.coeffRef(n) = coupled_state[n];
   }
 
@@ -60,13 +58,13 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
   Eigen::VectorXd f_y0_t0;
   if (is_var<T_t0>::value)
     f_y0_t0 = f(value_of(t0), value_of(y0).eval(), msgs, value_of(args)...);
-  
+
   const size_t total_vars = y0_vars + args_vars + t0_vars + t_vars;
 
   vari** varis
-    = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
-  double* partials
-    = ChainableStack::instance_->memalloc_.alloc_array<double>(N * total_vars);
+      = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
+  double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(
+      N * total_vars);
 
   vari** varis_ptr = varis;
   varis_ptr = save_varis(varis_ptr, y0);
@@ -74,31 +72,30 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
   varis_ptr = save_varis(varis_ptr, t0);
   varis_ptr = save_varis(varis_ptr, t);
 
-   for (size_t j = 0; j < N; ++j) {
-     double* partials_j = partials + j * total_vars;
-     for (size_t k = 0; k < y0_vars; ++k) {
-       partials_j[k] = coupled_state[N + y0_vars * k + j];
-     }
-
-     for (size_t k = 0; k < args_vars; ++k) {
-       partials_j[y0_vars + k] = coupled_state[N + N * y0_vars + N * k + j];
-     }
-
-     if (t0_vars > 0) {
-       double dyt_dt0 = 0.0;
-       for (size_t k = 0; k < y0_vars; ++k) {
-	 dyt_dt0 += -f_y0_t0.coeffRef(k) * coupled_state[N + y0_vars * k + j];
-       }
-       partials_j[y0_vars + args_vars] = dyt_dt0;
-     }
-
-     if (t_vars > 0) {
-       partials_j[y0_vars + args_vars + t0_vars] = f_y_t.coeffRef(j);
-     }
-
-     yt(j) = new precomputed_gradients_vari(y(j), total_vars,
-					    varis, partials_j);
-   }
+  for (size_t j = 0; j < N; ++j) {
+    double* partials_j = partials + j * total_vars;
+    for (size_t k = 0; k < y0_vars; ++k) {
+      partials_j[k] = coupled_state[N + y0_vars * k + j];
+    }
+
+    for (size_t k = 0; k < args_vars; ++k) {
+      partials_j[y0_vars + k] = coupled_state[N + N * y0_vars + N * k + j];
+    }
+
+    if (t0_vars > 0) {
+      double dyt_dt0 = 0.0;
+      for (size_t k = 0; k < y0_vars; ++k) {
+        dyt_dt0 += -f_y0_t0.coeffRef(k) * coupled_state[N + y0_vars * k + j];
+      }
+      partials_j[y0_vars + args_vars] = dyt_dt0;
+    }
+
+    if (t_vars > 0) {
+      partials_j[y0_vars + args_vars + t0_vars] = f_y_t.coeffRef(j);
+    }
+
+    yt(j) = new precomputed_gradients_vari(y(j), total_vars, varis, partials_j);
+  }
 
   return yt;
 }

From 1ef29d9ffa612215c0bc370a4e941df663354dda Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Tue, 30 Jun 2020 15:08:11 -0400
Subject: [PATCH 145/189] Updated function name in error messages to better
 reflect which function was called

Removed sensitivity tolerance flag (and set to true by default. It was false by default in 2.23 release)

(design-doc #19)
---
 stan/math/prim/functor/integrate_ode_rk45.hpp |  5 +-
 stan/math/prim/functor/ode_rk45.hpp           | 97 +++++++++++++++----
 stan/math/rev/functor/cvodes_integrator.hpp   | 96 +++++++++---------
 stan/math/rev/functor/cvodes_utils.hpp        |  8 +-
 stan/math/rev/functor/integrate_ode_adams.hpp |  5 +-
 stan/math/rev/functor/integrate_ode_bdf.hpp   |  4 +-
 stan/math/rev/functor/ode_adams.hpp           | 82 ++++++++++------
 stan/math/rev/functor/ode_bdf.hpp             | 86 +++++++++-------
 .../prim/functor/coupled_ode_system_test.cpp  | 36 +++----
 .../functor/integrate_ode_rk45_prim_test.cpp  | 22 +++++
 .../math/prim/functor/mock_ode_functor.hpp    | 16 +--
 .../functor/mock_throwing_ode_functor.hpp     | 11 ++-
 .../math/prim/functor/ode_rk45_prim_test.cpp  | 12 +++
 .../prim/functor/ode_rk45_tol_prim_test.cpp   | 13 +++
 test/unit/math/rev/functor/coupled_mm.hpp     |  4 +-
 .../math/rev/functor/ode_adams_prim_test.cpp  | 13 +++
 .../rev/functor/ode_adams_tol_prim_test.cpp   | 13 +++
 .../math/rev/functor/ode_bdf_prim_test.cpp    | 12 +++
 .../rev/functor/ode_bdf_tol_prim_test.cpp     | 13 +++
 19 files changed, 369 insertions(+), 179 deletions(-)

diff --git a/stan/math/prim/functor/integrate_ode_rk45.hpp b/stan/math/prim/functor/integrate_ode_rk45.hpp
index 9e3f755bebe..76a4c91f5dd 100644
--- a/stan/math/prim/functor/integrate_ode_rk45.hpp
+++ b/stan/math/prim/functor/integrate_ode_rk45.hpp
@@ -25,8 +25,9 @@ integrate_ode_rk45(const F& f, const std::vector<T1>& y0, const T_t0& t0,
                    double absolute_tolerance = 1e-6, int max_num_steps = 1e6) {
   internal::integrate_ode_std_vector_interface_adapter<F> f_adapted(f);
   auto y
-      = ode_rk45_tol(f_adapted, to_vector(y0), t0, ts, relative_tolerance,
-                     absolute_tolerance, max_num_steps, msgs, theta, x, x_int);
+    = ode_rk45_tol_impl("integrate_ode_rk45",
+			f_adapted, to_vector(y0), t0, ts, relative_tolerance,
+			absolute_tolerance, max_num_steps, msgs, theta, x, x_int);
 
   std::vector<std::vector<return_type_t<T1, T_param, T_t0, T_ts>>> y_converted;
   for (size_t i = 0; i < y.size(); ++i)
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index ea10bbc6ee3..30691db563e 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -41,8 +41,8 @@ namespace math {
  * @param t0 Initial time
  * @param ts Times at which to solve the ODE at. All values must be sorted and
  *   greater than t0.
- * @param relative_tolerance Relative tolerance passed to CVODES
- * @param absolute_tolerance Absolute tolerance passed to CVODES
+ * @param relative_tolerance Relative tolerance passed to Boost
+ * @param absolute_tolerance Absolute tolerance passed to Boost
  * @param max_num_steps Upper limit on the number of integration steps to
  *   take between each output (error if exceeded)
  * @param[in, out] msgs the print stream for warning messages
@@ -53,12 +53,12 @@ template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... Args>
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, Args...>,
                           Eigen::Dynamic, 1>>
-ode_rk45_tol(const F& f,
-             const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_arg, T_t0 t0,
-             const std::vector<T_ts>& ts, double relative_tolerance,
-             double absolute_tolerance,
-             long int max_num_steps,  // NOLINT(runtime/int)
-             std::ostream* msgs, const Args&... args) {
+ode_rk45_tol_impl(const char* function_name, const F& f,
+		  const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_arg, T_t0 t0,
+		  const std::vector<T_ts>& ts, double relative_tolerance,
+		  double absolute_tolerance,
+		  long int max_num_steps,  // NOLINT(runtime/int)
+		  std::ostream* msgs, const Args&... args) {
   using boost::numeric::odeint::integrate_times;
   using boost::numeric::odeint::make_dense_output;
   using boost::numeric::odeint::max_step_checker;
@@ -70,25 +70,25 @@ ode_rk45_tol(const F& f,
   Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1> y0 = y0_arg.
     unaryExpr([](const T_initial& val) { return T_initial_or_t0(val); });
 
-  check_finite("integrate_ode_rk45", "initial state", y0);
-  check_finite("integrate_ode_rk45", "initial time", t0);
-  check_finite("integrate_ode_rk45", "times", ts);
+  check_finite(function_name, "initial state", y0);
+  check_finite(function_name, "initial time", t0);
+  check_finite(function_name, "times", ts);
 
   // Code from https://stackoverflow.com/a/17340003
   std::vector<int> unused_temp{
-      0, (check_finite("integrate_ode_rk45", "ode parameters and data", args),
+      0, (check_finite(function_name, "ode parameters and data", args),
           0)...};
 
-  check_nonzero_size("integrate_ode_rk45", "initial state", y0);
-  check_nonzero_size("integrate_ode_rk45", "times", ts);
-  check_sorted("integrate_ode_rk45", "times", ts);
-  check_less("integrate_ode_rk45", "initial time", t0, ts[0]);
+  check_nonzero_size(function_name, "initial state", y0);
+  check_nonzero_size(function_name, "times", ts);
+  check_sorted(function_name, "times", ts);
+  check_less(function_name, "initial time", t0, ts[0]);
 
-  check_positive_finite("integrate_ode_rk45", "relative_tolerance",
+  check_positive_finite(function_name, "relative_tolerance",
                         relative_tolerance);
-  check_positive_finite("integrate_ode_rk45", "absolute_tolerance",
+  check_positive_finite(function_name, "absolute_tolerance",
                         absolute_tolerance);
-  check_positive("integrate_ode_rk45", "max_num_steps", max_num_steps);
+  check_positive(function_name, "max_num_steps", max_num_steps);
 
   using return_t = return_type_t<T_initial, T_t0, T_ts, Args...>;
   // creates basic or coupled system by template specializations
@@ -102,6 +102,7 @@ ode_rk45_tol(const F& f,
     ts_vec[i + 1] = value_of(ts[i]);
 
   std::vector<Eigen::Matrix<return_t, Eigen::Dynamic, 1>> y;
+  y.reserve(ts.size());
   bool observer_initial_recorded = false;
   size_t time_index = 0;
 
@@ -135,6 +136,59 @@ ode_rk45_tol(const F& f,
   return y;
 }
 
+/**
+ * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
+ * times, { t1, t2, t3, ... } using the non-stiff Runge-Kutta 45 solver in Boost
+ * with a relative tolerance of 1e-10, an absolute tolerance of 1e-10, and
+ * taking a maximum of 1e8 steps.
+ *
+ * If the system of equations is stiff, <code>ode_bdf</code> will likely be
+ * faster.
+ *
+ * \p f must define an operator() with the signature as:
+ *   template<typename T_t, typename T_y, typename... T_Args>
+ *   Eigen::Matrix<stan::return_type_t<T_t, T_y, T_Args...>, Eigen::Dynamic, 1>
+ *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
+ *     std::ostream* msgs, const T_Args&... args);
+ *
+ * t is the time, y is the state, msgs is a stream for error messages, and args
+ * are optional arguments passed to the ODE solve function (which are passed
+ * through to \p f without modification).
+ *
+ * @tparam F Type of ODE right hand side
+ * @tparam T_0 Type of initial time
+ * @tparam T_ts Type of output times
+ * @tparam T_Args Types of pass-through parameters
+ *
+ * @param f Right hand side of the ODE
+ * @param y0_arg Initial state
+ * @param t0 Initial time
+ * @param ts Times at which to solve the ODE at. All values must be sorted and
+ *   greater than t0.
+ * @param relative_tolerance Relative tolerance passed to Boost
+ * @param absolute_tolerance Absolute tolerance passed to Boost
+ * @param max_num_steps Upper limit on the number of integration steps to
+ *   take between each output (error if exceeded)
+ * @param[in, out] msgs the print stream for warning messages
+ * @param args Extra arguments passed unmodified through to ODE right hand side
+ * @return Solution to ODE at times \p ts
+ */
+template <typename F, typename T_initial, typename T_t0, typename T_ts,
+          typename... Args>
+std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, Args...>,
+                          Eigen::Dynamic, 1>>
+ode_rk45_tol(const F& f,
+	     const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_arg, T_t0 t0,
+	     const std::vector<T_ts>& ts, double relative_tolerance,
+	     double absolute_tolerance,
+	     long int max_num_steps,  // NOLINT(runtime/int)
+	     std::ostream* msgs, const Args&... args) {
+  return ode_rk45_tol_impl("ode_rk45_tol", f, y0_arg, t0, ts,
+			   relative_tolerance, absolute_tolerance,
+			   max_num_steps, msgs,
+			   args...);
+}
+
 /**
  * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
  * times, { t1, t2, t3, ... } using the non-stiff Runge-Kutta 45 solver in Boost
@@ -179,8 +233,9 @@ ode_rk45(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
   double absolute_tolerance = 1e-10;
   long int max_num_steps = 1e8;  // NOLINT(runtime/int)
 
-  return ode_rk45_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
-                      max_num_steps, msgs, args...);
+  return ode_rk45_tol_impl("ode_rk45",
+			   f, y0, t0, ts, relative_tolerance, absolute_tolerance,
+			   max_num_steps, msgs, args...);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 99fd4091ff8..37b86acdbd7 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -34,6 +34,7 @@ class cvodes_integrator {
   using T_Return = return_type_t<T_y0, T_t0, T_ts, T_Args...>;
   using T_y0_t0 = return_type_t<T_y0, T_t0>;
 
+  const char* function_name_;
   const F& f_;
   const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1> y0_;
   const T_t0 t0_;
@@ -45,7 +46,6 @@ class cvodes_integrator {
   std::ostream* msgs_;
   double relative_tolerance_;
   double absolute_tolerance_;
-  bool include_sensitivities_in_errors_;
   long int max_num_steps_;  // NOLINT(runtime/int)
 
   const size_t y0_vars_;
@@ -167,8 +167,6 @@ class cvodes_integrator {
    *   not less than t0.
    * @param relative_tolerance Relative tolerance passed to CVODES
    * @param absolute_tolerance Absolute tolerance passed to CVODES
-   * @param include_sensitivities_in_errors A bool to determine whether
-   * to store the sensitivities in errors
    * @param max_num_steps Upper limit on the number of integration steps to
    *   take between each output (error if exceeded)
    * @param[in, out] msgs the print stream for warning messages
@@ -183,51 +181,48 @@ class cvodes_integrator {
    * @throw <code>std::invalid_argument</code> if arguments are the wrong
    *   size or tolerances or max_num_steps are out of range.
    */
-  cvodes_integrator(const F& f,
+  cvodes_integrator(const char* function_name, const F& f,
                     const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
                     const T_t0& t0, const std::vector<T_ts>& ts,
                     double relative_tolerance, double absolute_tolerance,
-                    bool include_sensitivities_in_errors,
                     long int max_num_steps,  // NOLINT(runtime/int)
                     std::ostream* msgs, const T_Args&... args)
-      : f_(f),
-        y0_(y0.unaryExpr([](const T_y0& val) { return T_y0_t0(val); })),
-        t0_(t0),
-        ts_(ts),
-        args_tuple_(args...),
-        value_of_args_tuple_(value_of(args)...),
-        N_(y0.size()),
-        msgs_(msgs),
-        relative_tolerance_(relative_tolerance),
-        absolute_tolerance_(absolute_tolerance),
-        include_sensitivities_in_errors_(include_sensitivities_in_errors),
-        max_num_steps_(max_num_steps),
-        y0_vars_(count_vars(y0_)),
-        args_vars_(count_vars(args...)),
-        coupled_ode_(f, y0_, msgs, args...),
-        coupled_state_(coupled_ode_.initial_state()) {
-    const char* fun = "cvodes_integrator::integrate";
-
-    check_finite(fun, "initial state", y0_);
-    check_finite(fun, "initial time", t0_);
-    check_finite(fun, "times", ts_);
+    : function_name_(function_name),
+      f_(f),
+      y0_(y0.unaryExpr([](const T_y0& val) { return T_y0_t0(val); })),
+      t0_(t0),
+      ts_(ts),
+      args_tuple_(args...),
+      value_of_args_tuple_(value_of(args)...),
+      N_(y0.size()),
+      msgs_(msgs),
+      relative_tolerance_(relative_tolerance),
+      absolute_tolerance_(absolute_tolerance),
+      max_num_steps_(max_num_steps),
+      y0_vars_(count_vars(y0_)),
+      args_vars_(count_vars(args...)),
+      coupled_ode_(f, y0_, msgs, args...),
+      coupled_state_(coupled_ode_.initial_state()) {
+    check_finite(function_name, "initial state", y0_);
+    check_finite(function_name, "initial time", t0_);
+    check_finite(function_name, "times", ts_);
 
     // Code from: https://stackoverflow.com/a/17340003 . Should probably do
     // something better
     apply(
         [&](auto&&... args) {
           std::vector<int> unused_temp{
-              0, (check_finite(fun, "ode parameters and data", args), 0)...};
+              0, (check_finite(function_name, "ode parameters and data", args), 0)...};
         },
         args_tuple_);
 
-    check_nonzero_size(fun, "times", ts_);
-    check_nonzero_size(fun, "initial state", y0_);
-    check_sorted(fun, "times", ts_);
-    check_less(fun, "initial time", t0_, ts_[0]);
-    check_positive_finite(fun, "relative_tolerance", relative_tolerance_);
-    check_positive_finite(fun, "absolute_tolerance", absolute_tolerance_);
-    check_positive(fun, "max_num_steps", max_num_steps_);
+    check_nonzero_size(function_name, "times", ts_);
+    check_nonzero_size(function_name, "initial state", y0_);
+    check_sorted(function_name, "times", ts_);
+    check_less(function_name, "initial time", t0_, ts_[0]);
+    check_positive_finite(function_name, "relative_tolerance", relative_tolerance_);
+    check_positive_finite(function_name, "absolute_tolerance", absolute_tolerance_);
+    check_positive(function_name, "max_num_steps", max_num_steps_);
 
     nv_state_ = N_VMake_Serial(N_, &coupled_state_[0]);
     nv_state_sens_ = nullptr;
@@ -304,13 +299,8 @@ class cvodes_integrator {
                           nv_state_sens_),
             "CVodeSensInit");
 
-        if (include_sensitivities_in_errors_) {
-          check_flag_sundials(CVodeSetSensErrCon(cvodes_mem, SUNTRUE),
-                              "CVodeSetSensErrCon");
-        } else {
-          check_flag_sundials(CVodeSetSensErrCon(cvodes_mem, SUNFALSE),
-                              "CVodeSetSensErrCon");
-        }
+	check_flag_sundials(CVodeSetSensErrCon(cvodes_mem, SUNTRUE),
+			    "CVodeSetSensErrCon");
 
         if (atols.size() > 0) {
           check_positive_finite("cvodes_integrator",
@@ -333,15 +323,21 @@ class cvodes_integrator {
         double t_final = value_of(ts_[n]);
 
         if (t_final != t_init) {
-          check_flag_sundials(
-              CVode(cvodes_mem, t_final, nv_state_, &t_init, CV_NORMAL),
-              "CVode");
-
-          if (y0_vars_ + args_vars_ > 0) {
-            check_flag_sundials(
-                CVodeGetSens(cvodes_mem, &t_init, nv_state_sens_),
-                "CVodeGetSens");
-          }
+          int error_code =
+              CVode(cvodes_mem, t_final, nv_state_, &t_init, CV_NORMAL);
+
+	  if (error_code == CV_TOO_MUCH_WORK) {
+	    throw_domain_error(function_name_, "", t_final,
+			       "Failed to integrate to next output time (",
+			       ") in less than max_num_steps steps");
+	  } else {
+	    check_flag_sundials(error_code, "CVode");
+	  }
+
+	  if (y0_vars_ + args_vars_ > 0) {
+	    check_flag_sundials(CVodeGetSens(cvodes_mem, &t_init, nv_state_sens_),
+				"CVodeGetSens");
+	  }
         }
 
         y.emplace_back(apply(
diff --git a/stan/math/rev/functor/cvodes_utils.hpp b/stan/math/rev/functor/cvodes_utils.hpp
index 8b82e52cd18..17d99bcc630 100644
--- a/stan/math/rev/functor/cvodes_utils.hpp
+++ b/stan/math/rev/functor/cvodes_utils.hpp
@@ -13,10 +13,12 @@ namespace math {
 extern "C" inline void cvodes_err_handler(int error_code, const char* module,
                                           const char* function, char* msg,
                                           void* eh_data) {
-  std::ostringstream msg1;
-  msg1 << msg << " Error code: ";
+  if(error_code != CV_TOO_MUCH_WORK) {
+    std::ostringstream msg1;
+    msg1 << msg << " Error code: ";
 
-  domain_error(module, function, error_code, msg1.str().c_str());
+    throw_domain_error(module, function, error_code, msg1.str().c_str());
+  }
 }
 
 inline void cvodes_set_options(void* cvodes_mem, double rel_tol, double abs_tol,
diff --git a/stan/math/rev/functor/integrate_ode_adams.hpp b/stan/math/rev/functor/integrate_ode_adams.hpp
index ef339e1bdbf..79ac477a4a2 100644
--- a/stan/math/rev/functor/integrate_ode_adams.hpp
+++ b/stan/math/rev/functor/integrate_ode_adams.hpp
@@ -26,8 +26,9 @@ integrate_ode_adams(const F& f, const std::vector<T_initial>& y0,
                     long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
   internal::integrate_ode_std_vector_interface_adapter<F> f_adapted(f);
   auto y
-      = ode_adams_tol(f_adapted, to_vector(y0), t0, ts, relative_tolerance,
-                      absolute_tolerance, max_num_steps, msgs, theta, x, x_int);
+    = ode_adams_tol_impl("integrate_ode_adams",
+			 f_adapted, to_vector(y0), t0, ts, relative_tolerance,
+			 absolute_tolerance, max_num_steps, msgs, theta, x, x_int);
 
   std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>>
       y_converted;
diff --git a/stan/math/rev/functor/integrate_ode_bdf.hpp b/stan/math/rev/functor/integrate_ode_bdf.hpp
index 33b0c4a7039..b97cebd05ca 100644
--- a/stan/math/rev/functor/integrate_ode_bdf.hpp
+++ b/stan/math/rev/functor/integrate_ode_bdf.hpp
@@ -26,8 +26,8 @@ integrate_ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
                   long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
   internal::integrate_ode_std_vector_interface_adapter<F> f_adapted(f);
   auto y
-      = ode_bdf_tol(f_adapted, to_vector(y0), t0, ts, relative_tolerance,
-                    absolute_tolerance, max_num_steps, msgs, theta, x, x_int);
+    = ode_bdf_tol_impl("integrate_ode_bdf", f_adapted, to_vector(y0), t0, ts, relative_tolerance,
+		       absolute_tolerance, max_num_steps, msgs, theta, x, x_int);
 
   std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>>
       y_converted;
diff --git a/stan/math/rev/functor/ode_adams.hpp b/stan/math/rev/functor/ode_adams.hpp
index 9735635b1d0..6f6662a08aa 100644
--- a/stan/math/rev/functor/ode_adams.hpp
+++ b/stan/math/rev/functor/ode_adams.hpp
@@ -8,36 +8,54 @@
 
 namespace stan {
 namespace math {
-template <typename F, typename T_initial, typename T_t0, typename T_ts,
-          typename... T_Args>
-std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
-                          Eigen::Dynamic, 1>>
-ode_adams_tol_sens_error(const F& f,
-                         const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-                         const T_t0& t0, const std::vector<T_ts>& ts,
-                         double rtol, double atol, double rtols,
-                         const std::vector<double>& atols,
-                         long int max_num_steps,  // NOLINT(runtime/int)
-                         std::ostream* msgs, const T_Args&... args) {
-  cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
-      f, y0, t0, ts, rtol, atol, true, max_num_steps, msgs, args...);
-
-  return integrator(rtols, atols);
-}
 
+/**
+ * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
+ * times, { t1, t2, t3, ... } using the stiff backward differentiation formula
+ * Adams-Moulton solver from CVODES.
+ *
+ * \p f must define an operator() with the signature as:
+ *   template<typename T_t, typename T_y, typename... T_Args>
+ *   Eigen::Matrix<stan::return_type_t<T_t, T_y, T_Args...>, Eigen::Dynamic, 1>
+ *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
+ *     std::ostream* msgs, const T_Args&... args);
+ *
+ * t is the time, y is the state, msgs is a stream for error messages, and args
+ * are optional arguments passed to the ODE solve function (which are passed
+ * through to \p f without modification).
+ *
+ * @tparam F Type of ODE right hand side
+ * @tparam T_0 Type of initial time
+ * @tparam T_ts Type of output times
+ * @tparam T_Args Types of pass-through parameters
+ *
+ * @param f Right hand side of the ODE
+ * @param y0 Initial state
+ * @param t0 Initial time
+ * @param ts Times at which to solve the ODE at. All values must be sorted and
+ *   not less than t0.
+ * @param relative_tolerance Relative tolerance passed to CVODES
+ * @param absolute_tolerance Absolute tolerance passed to CVODES
+ * @param max_num_steps Upper limit on the number of integration steps to
+ *   take between each output (error if exceeded)
+ * @param[in, out] msgs the print stream for warning messages
+ * @param args Extra arguments passed unmodified through to ODE right hand side
+ * @return Solution to ODE at times \p ts
+ */
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
-ode_adams_tol_error(const F& f,
-                    const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-                    const T_t0& t0, const std::vector<T_ts>& ts,
-                    double relative_tolerance, double absolute_tolerance,
-                    long int max_num_steps,  // NOLINT(runtime/int)
-                    std::ostream* msgs, const T_Args&... args) {
-  cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
-      f, y0, t0, ts, relative_tolerance, absolute_tolerance, true,
-      max_num_steps, msgs, args...);
+ode_adams_tol_impl(const char* function_name,
+		   const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+		   const T_t0& t0, const std::vector<T_ts>& ts,
+		   double relative_tolerance, double absolute_tolerance,
+		   long int max_num_steps,  // NOLINT(runtime/int)
+		   std::ostream* msgs, const T_Args&... args) {
+  cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator
+    (function_name,
+     f, y0, t0, ts, relative_tolerance, absolute_tolerance,
+     max_num_steps, msgs, args...);
 
   return integrator();
 }
@@ -84,11 +102,9 @@ ode_adams_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
               double relative_tolerance, double absolute_tolerance,
               long int max_num_steps,  // NOLINT(runtime/int)
               std::ostream* msgs, const T_Args&... args) {
-  cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
-      f, y0, t0, ts, relative_tolerance, absolute_tolerance, false,
-      max_num_steps, msgs, args...);
-
-  return integrator();
+  return ode_adams_tol_impl("ode_adams_tol",
+			    f, y0, t0, ts, relative_tolerance, absolute_tolerance,
+			    max_num_steps, msgs, args...);
 }
 
 /**
@@ -132,8 +148,10 @@ ode_adams(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
   double absolute_tolerance = 1e-10;
   long int max_num_steps = 1e8;  // NOLINT(runtime/int)
 
-  return ode_adams_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
-                       max_num_steps, msgs, args...);
+  return ode_adams_tol_impl("ode_adams",
+			    f, y0, t0, ts,
+			    relative_tolerance, absolute_tolerance,
+			    max_num_steps, msgs, args...);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 32c2c974baf..552cb312563 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -9,35 +9,50 @@
 namespace stan {
 namespace math {
 
+/**
+ * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
+ * times, { t1, t2, t3, ... } using the stiff backward differentiation formula
+ * BDF solver from CVODES.
+ *
+ * \p f must define an operator() with the signature as:
+ *   template<typename T_t, typename T_y, typename... T_Args>
+ *   Eigen::Matrix<stan::return_type_t<T_t, T_y, T_Args...>, Eigen::Dynamic, 1>
+ *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
+ *     std::ostream* msgs, const T_Args&... args);
+ *
+ * t is the time, y is the state, msgs is a stream for error messages, and args
+ * are optional arguments passed to the ODE solve function (which are passed
+ * through to \p f without modification).
+ *
+ * @tparam F Type of ODE right hand side
+ * @tparam T_0 Type of initial time
+ * @tparam T_ts Type of output times
+ * @tparam T_Args Types of pass-through parameters
+ *
+ * @param f Right hand side of the ODE
+ * @param y0 Initial state
+ * @param t0 Initial time
+ * @param ts Times at which to solve the ODE at. All values must be sorted and
+ *   not less than t0.
+ * @param relative_tolerance Relative tolerance passed to CVODES
+ * @param absolute_tolerance Absolute tolerance passed to CVODES
+ * @param max_num_steps Upper limit on the number of integration steps to
+ *   take between each output (error if exceeded)
+ * @param[in, out] msgs the print stream for warning messages
+ * @param args Extra arguments passed unmodified through to ODE right hand side
+ * @return Solution to ODE at times \p ts
+ */
 template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
-ode_bdf_tol_sens_error(const F& f,
-                       const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-                       const T_t0& t0, const std::vector<T_ts>& ts, double rtol,
-                       double atol, double rtols,
-                       const std::vector<double>& atols,
-                       long int max_num_steps,  // NOLINT(runtime/int)
-                       std::ostream* msgs, const T_Args&... args) {
-  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
-      f, y0, t0, ts, rtol, atol, true, max_num_steps, msgs, args...);
-
-  return integrator(rtols, atols);
-}
-
-template <typename F, typename T_initial, typename T_t0, typename T_ts,
-          typename... T_Args>
-std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
-                          Eigen::Dynamic, 1>>
-ode_bdf_tol_error(const F& f,
-                  const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-                  const T_t0& t0, const std::vector<T_ts>& ts,
-                  double relative_tolerance, double absolute_tolerance,
-                  long int max_num_steps,  // NOLINT(runtime/int)
-                  std::ostream* msgs, const T_Args&... args) {
-  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
-      f, y0, t0, ts, relative_tolerance, absolute_tolerance, true,
+ode_bdf_tol_impl(const char* function_name,
+		 const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+		 const T_t0& t0, const std::vector<T_ts>& ts,
+		 double relative_tolerance, double absolute_tolerance,
+		 long int max_num_steps,  // NOLINT(runtime/int)
+		 std::ostream* msgs, const T_Args&... args) {
+  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(function_name, f, y0, t0, ts, relative_tolerance, absolute_tolerance,
       max_num_steps, msgs, args...);
 
   return integrator();
@@ -81,15 +96,13 @@ template <typename F, typename T_initial, typename T_t0, typename T_ts,
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
 ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-            const T_t0& t0, const std::vector<T_ts>& ts,
-            double relative_tolerance, double absolute_tolerance,
-            long int max_num_steps,  // NOLINT(runtime/int)
-            std::ostream* msgs, const T_Args&... args) {
-  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
-      f, y0, t0, ts, relative_tolerance, absolute_tolerance, false,
-      max_num_steps, msgs, args...);
-
-  return integrator();
+	    const T_t0& t0, const std::vector<T_ts>& ts,
+	    double relative_tolerance, double absolute_tolerance,
+	    long int max_num_steps,  // NOLINT(runtime/int)
+	    std::ostream* msgs, const T_Args&... args) {
+  return ode_bdf_tol_impl("ode_bdf_tol", f, y0, t0, ts,
+			  relative_tolerance, absolute_tolerance,
+			  max_num_steps, msgs, args...);
 }
 
 /**
@@ -133,8 +146,9 @@ ode_bdf(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
   double absolute_tolerance = 1e-10;
   long int max_num_steps = 1e8;  // NOLINT(runtime/int)
 
-  return ode_bdf_tol(f, y0, t0, ts, relative_tolerance, absolute_tolerance,
-                     max_num_steps, msgs, args...);
+  return ode_bdf_tol_impl("ode_bdf", f, y0, t0, ts,
+			  relative_tolerance, absolute_tolerance,
+			  max_num_steps, msgs, args...);
 }
 
 }  // namespace math
diff --git a/test/unit/math/prim/functor/coupled_ode_system_test.cpp b/test/unit/math/prim/functor/coupled_ode_system_test.cpp
index 2022067e2af..7560596779a 100644
--- a/test/unit/math/prim/functor/coupled_ode_system_test.cpp
+++ b/test/unit/math/prim/functor/coupled_ode_system_test.cpp
@@ -20,24 +20,24 @@ TEST_F(StanMathOde, initial_state_dd) {
   const int N = 3;
   const int M = 4;
 
-  std::vector<double> y0_d(N, 0.0);
-  std::vector<double> theta_d(M, 0.0);
+  Eigen::VectorXd y0_d(N);
+  std::vector<double> theta_d(M);
 
   for (int n = 0; n < N; n++)
-    y0_d[n] = n + 1;
+    y0_d(n) = n + 1;
   for (int m = 0; m < M; m++)
     theta_d[m] = 10 * (m + 1);
 
-  coupled_ode_system<mock_ode_functor, double, double> coupled_system_dd(
-      base_ode, y0_d, theta_d, x, x_int, &msgs);
+  coupled_ode_system<mock_ode_functor, double, std::vector<double>, std::vector<double>, std::vector<int>> coupled_system_dd(
+      base_ode, y0_d, &msgs, theta_d, x, x_int);
 
-  std::vector<double> state = coupled_system_dd.initial_state();
+  Eigen::VectorXd state = coupled_system_dd.initial_state();
   for (int n = 0; n < N; n++)
-    EXPECT_FLOAT_EQ(y0_d[n], state[n])
+    EXPECT_FLOAT_EQ(y0_d(n), state(n))
         << "we don't need derivatives of y0; "
         << "initial state gets the initial values";
   for (size_t n = N; n < state.size(); n++)
-    EXPECT_FLOAT_EQ(0.0, state[n]);
+    EXPECT_FLOAT_EQ(0.0, state(n));
 }
 
 TEST_F(StanMathOde, size) {
@@ -47,11 +47,12 @@ TEST_F(StanMathOde, size) {
   const int N = 3;
   const int M = 4;
 
-  std::vector<double> y0_d(N, 0.0);
+  Eigen::VectorXd y0_d(N);
   std::vector<double> theta_d(M, 0.0);
 
-  coupled_ode_system<mock_ode_functor, double, double> coupled_system_dd(
-      base_ode, y0_d, theta_d, x, x_int, &msgs);
+  coupled_ode_system<mock_ode_functor, double,
+		     int, double,
+		     Eigen::MatrixXd> coupled_system_dd(base_ode, y0_d, &msgs, 1, 1.0, y0_d);
 
   EXPECT_EQ(N, coupled_system_dd.size());
 }
@@ -65,17 +66,18 @@ TEST_F(StanMathOde, recover_exception) {
 
   mock_throwing_ode_functor<std::logic_error> throwing_ode(message);
 
-  std::vector<double> y0_d(N, 0.0);
-  std::vector<double> theta_v(M, 0.0);
+  Eigen::VectorXd y0_d(N);
+  std::vector<double> theta_v(M);
 
   coupled_ode_system<mock_throwing_ode_functor<std::logic_error>, double,
-                     double>
-      coupled_system_dd(throwing_ode, y0_d, theta_v, x, x_int, &msgs);
+                     std::vector<double>, std::vector<double>, std::vector<int>>
+      coupled_system_dd(throwing_ode, y0_d, &msgs, theta_v, x, x_int);
 
-  std::vector<double> y(3, 0);
-  std::vector<double> dy_dt(3, 0);
+  Eigen::VectorXd y(3);
+  Eigen::VectorXd dy_dt(3);
 
   double t = 10;
 
   EXPECT_THROW_MSG(coupled_system_dd(y, dy_dt, t), std::logic_error, message);
 }
+
diff --git a/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp b/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
index f04b083fff5..6d665abd7ec 100644
--- a/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
+++ b/test/unit/math/prim/functor/integrate_ode_rk45_prim_test.cpp
@@ -333,3 +333,25 @@ TEST(StanMathOde_integrate_ode_rk45, error_conditions_inf) {
         std::domain_error, expected_is_neg_inf.str());
   }
 }
+
+TEST(StanMathOde_integrate_ode_rk45, error_name) {
+  using stan::math::integrate_ode_rk45;
+  harm_osc_ode_data_fun harm_osc;
+
+  std::vector<double> theta;
+  theta.push_back(0.15);
+
+  double t0 = 0;
+
+  std::vector<double> ts;
+  for (int i = 0; i < 100; i++)
+    ts.push_back(t0 + 0.1 * (i + 1));
+
+  std::vector<double> x(3, 1);
+  std::vector<int> x_int(2, 0);
+
+  std::vector<double> y0_bad;
+  EXPECT_THROW_MSG(
+      (integrate_ode_rk45(harm_osc, y0_bad, t0, ts, theta, x, x_int)),
+      std::invalid_argument, "integrate_ode_rk45");
+}
diff --git a/test/unit/math/prim/functor/mock_ode_functor.hpp b/test/unit/math/prim/functor/mock_ode_functor.hpp
index 88b3065b458..6c95e951c6b 100644
--- a/test/unit/math/prim/functor/mock_ode_functor.hpp
+++ b/test/unit/math/prim/functor/mock_ode_functor.hpp
@@ -1,13 +1,13 @@
 #include <vector>
 
 struct mock_ode_functor {
-  template <typename T0, typename T1, typename T2>
-  inline std::vector<stan::return_type_t<T1, T2>> operator()(
-      const T0& t_in, const std::vector<T1>& y_in, const std::vector<T2>& theta,
-      const std::vector<double>& x, const std::vector<int>& x_int,
-      std::ostream* msgs) const {
-    std::vector<stan::return_type_t<T1, T2>> states;
-    states = y_in;
-    return states;
+  template <typename T0, typename T1, typename T2, typename T3, typename T4>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2, T3, T4>, Eigen::Dynamic, 1>
+  operator()(const T0& t_in, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y_in,
+	     std::ostream* msgs,
+	     const T2& a1,
+	     const T3& a2,
+	     const T4& a3) const {
+    return y_in.template cast<stan::return_type_t<T1, T2, T3, T4>>();
   }
 };
diff --git a/test/unit/math/prim/functor/mock_throwing_ode_functor.hpp b/test/unit/math/prim/functor/mock_throwing_ode_functor.hpp
index 285a9b749b5..cf37d5fdaab 100644
--- a/test/unit/math/prim/functor/mock_throwing_ode_functor.hpp
+++ b/test/unit/math/prim/functor/mock_throwing_ode_functor.hpp
@@ -17,10 +17,13 @@ struct mock_throwing_ode_functor {
   }
 
   template <typename T0, typename T1, typename T2>
-  inline std::vector<stan::return_type_t<T1, T2>> operator()(
-      const T0& t_in, const std::vector<T1>& y_in, const std::vector<T2>& theta,
-      const std::vector<double>& x, const std::vector<int>& x_int,
-      std::ostream* msgs) const {
+  inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1>
+  operator()(const T0& t_in,
+	     const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y_in,
+	     std::ostream* msgs,
+	     const std::vector<T2>& theta,
+	     const std::vector<double>& x,
+	     const std::vector<int>& x_int) const {
     mock_throwing_ode_functor_count++;
     if (N_ == mock_throwing_ode_functor_count)
       throw E(msg_);
diff --git a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
index 4fa3afb0438..22564ec9d7f 100644
--- a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
@@ -1,5 +1,6 @@
 #include <stan/math/rev.hpp>
 #include <gtest/gtest.h>
+#include <test/unit/util.hpp>
 #include <iostream>
 #include <vector>
 
@@ -238,3 +239,14 @@ TEST(ode_rk45_prim, rhs_wrong_size_errors) {
   EXPECT_THROW(stan::math::ode_rk45(CosArgWrongSize(), y0, t0, ts, nullptr, a),
                std::invalid_argument);
 }
+
+TEST(ode_rk45_prim, error_name) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double ainf = stan::math::INFTY;
+
+  EXPECT_THROW_MSG(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, ainf),
+		   std::domain_error, "ode_rk45");
+}
diff --git a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
index 8a4af680083..6c8c4d689fe 100644
--- a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
@@ -1,5 +1,6 @@
 #include <stan/math/prim.hpp>
 #include <gtest/gtest.h>
+#include <test/unit/util.hpp>
 #include <iostream>
 #include <vector>
 
@@ -349,3 +350,15 @@ TEST(ode_rk45_tol_prim, rhs_wrong_size_errors) {
                                         1e-6, 100, nullptr, a),
                std::invalid_argument);
 }
+
+TEST(ode_rk45_tol_prim, error_name) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double ainf = stan::math::INFTY;
+
+  EXPECT_THROW_MSG(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6, 100,
+					nullptr, ainf),
+               std::domain_error, "ode_rk45_tol");
+}
diff --git a/test/unit/math/rev/functor/coupled_mm.hpp b/test/unit/math/rev/functor/coupled_mm.hpp
index 49d13a268b7..a1864f130ed 100644
--- a/test/unit/math/rev/functor/coupled_mm.hpp
+++ b/test/unit/math/rev/functor/coupled_mm.hpp
@@ -12,9 +12,9 @@ struct coupled_mm_ode_fun {
   // parameters
   // double data
   // integer data
-  operator()(const T0& t_in, const std::vector<T1>& y,
+  operator()(const T0& t_in, const std::vector<T1>& y, std::ostream* msgs,
              const std::vector<T2>& parms, const std::vector<double>& sx,
-             const std::vector<int>& sx_int, std::ostream* msgs) const {
+             const std::vector<int>& sx_int) const {
     std::vector<stan::return_type_t<T1, T2>> ydot(2);
 
     const T2 act = parms[0];
diff --git a/test/unit/math/rev/functor/ode_adams_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
index 5d545b8d3cd..678ce544610 100644
--- a/test/unit/math/rev/functor/ode_adams_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
@@ -1,5 +1,6 @@
 #include <stan/math/rev.hpp>
 #include <gtest/gtest.h>
+#include <test/unit/util.hpp>
 #include <iostream>
 #include <vector>
 
@@ -238,3 +239,15 @@ TEST(ode_adams_prim, rhs_wrong_size_errors) {
   EXPECT_THROW(stan::math::ode_adams(CosArgWrongSize(), y0, t0, ts, nullptr, a),
                std::invalid_argument);
 }
+
+TEST(ode_adams_prim, error_name) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double ainf = stan::math::INFTY;
+
+  EXPECT_THROW_MSG(stan::math::ode_adams(CosArg1(), y0, t0, ts,
+					nullptr, ainf),
+               std::domain_error, "ode_adams");
+}
diff --git a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
index ac53cc574ed..a1e65568be6 100644
--- a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
@@ -1,5 +1,6 @@
 #include <stan/math/rev.hpp>
 #include <gtest/gtest.h>
+#include <test/unit/util.hpp>
 #include <iostream>
 #include <vector>
 
@@ -349,3 +350,15 @@ TEST(ode_adams_tol_prim, rhs_wrong_size_errors) {
                                          1e-6, 100, nullptr, a),
                std::invalid_argument);
 }
+
+TEST(ode_adams_tol_prim, error_name) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double ainf = stan::math::INFTY;
+
+  EXPECT_THROW_MSG(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6, 100,
+					nullptr, ainf),
+               std::domain_error, "ode_adams_tol");
+}
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index 38407be8aca..75c3a3d2d33 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -1,5 +1,6 @@
 #include <stan/math/rev.hpp>
 #include <gtest/gtest.h>
+#include <test/unit/util.hpp>
 #include <iostream>
 #include <vector>
 
@@ -238,3 +239,14 @@ TEST(ode_bdf_prim, rhs_wrong_size_errors) {
   EXPECT_THROW(stan::math::ode_bdf(CosArgWrongSize(), y0, t0, ts, nullptr, a),
                std::invalid_argument);
 }
+
+TEST(ode_bdf_prim, error_name) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double ainf = stan::math::INFTY;
+
+  EXPECT_THROW_MSG(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, ainf),
+		   std::domain_error, "ode_bdf");
+}
diff --git a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
index c9c4a9dbe9d..364b5a62d1d 100644
--- a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
@@ -1,5 +1,6 @@
 #include <stan/math/rev.hpp>
 #include <gtest/gtest.h>
+#include <test/unit/util.hpp>
 #include <iostream>
 #include <vector>
 
@@ -349,3 +350,15 @@ TEST(ode_bdf_tol_prim, rhs_wrong_size_errors) {
                                        1e-6, 100, nullptr, a),
                std::invalid_argument);
 }
+
+TEST(ode_bdf_tol_prim, error_name) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  double ainf = stan::math::INFTY;
+
+  EXPECT_THROW_MSG(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+					   100, nullptr, ainf),
+		   std::domain_error, "ode_bdf_tol");
+}

From 4851d6bccc491c339b43a40d1a4858327e93e18e Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Tue, 30 Jun 2020 19:13:37 +0000
Subject: [PATCH 146/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

---
 stan/math/prim/functor/integrate_ode_rk45.hpp |  7 +-
 stan/math/prim/functor/ode_rk45.hpp           | 33 ++++----
 stan/math/rev/functor/cvodes_integrator.hpp   | 76 ++++++++++---------
 stan/math/rev/functor/cvodes_utils.hpp        |  2 +-
 stan/math/rev/functor/integrate_ode_adams.hpp |  7 +-
 stan/math/rev/functor/integrate_ode_bdf.hpp   |  6 +-
 stan/math/rev/functor/ode_adams.hpp           | 30 ++++----
 stan/math/rev/functor/ode_bdf.hpp             | 33 ++++----
 .../prim/functor/coupled_ode_system_test.cpp  | 11 ++-
 .../math/prim/functor/mock_ode_functor.hpp    |  6 +-
 .../functor/mock_throwing_ode_functor.hpp     | 10 +--
 .../math/prim/functor/ode_rk45_prim_test.cpp  |  2 +-
 .../prim/functor/ode_rk45_tol_prim_test.cpp   |  6 +-
 .../math/rev/functor/ode_adams_prim_test.cpp  |  5 +-
 .../rev/functor/ode_adams_tol_prim_test.cpp   |  6 +-
 .../math/rev/functor/ode_bdf_prim_test.cpp    |  2 +-
 .../rev/functor/ode_bdf_tol_prim_test.cpp     |  4 +-
 17 files changed, 117 insertions(+), 129 deletions(-)

diff --git a/stan/math/prim/functor/integrate_ode_rk45.hpp b/stan/math/prim/functor/integrate_ode_rk45.hpp
index 76a4c91f5dd..78a061fdd0b 100644
--- a/stan/math/prim/functor/integrate_ode_rk45.hpp
+++ b/stan/math/prim/functor/integrate_ode_rk45.hpp
@@ -24,10 +24,9 @@ integrate_ode_rk45(const F& f, const std::vector<T1>& y0, const T_t0& t0,
                    double relative_tolerance = 1e-6,
                    double absolute_tolerance = 1e-6, int max_num_steps = 1e6) {
   internal::integrate_ode_std_vector_interface_adapter<F> f_adapted(f);
-  auto y
-    = ode_rk45_tol_impl("integrate_ode_rk45",
-			f_adapted, to_vector(y0), t0, ts, relative_tolerance,
-			absolute_tolerance, max_num_steps, msgs, theta, x, x_int);
+  auto y = ode_rk45_tol_impl("integrate_ode_rk45", f_adapted, to_vector(y0), t0,
+                             ts, relative_tolerance, absolute_tolerance,
+                             max_num_steps, msgs, theta, x, x_int);
 
   std::vector<std::vector<return_type_t<T1, T_param, T_t0, T_ts>>> y_converted;
   for (size_t i = 0; i < y.size(); ++i)
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index 36e7f56889b..d8276fa613c 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -54,11 +54,11 @@ template <typename F, typename T_initial, typename T_t0, typename T_ts,
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, Args...>,
                           Eigen::Dynamic, 1>>
 ode_rk45_tol_impl(const char* function_name, const F& f,
-		  const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_arg, T_t0 t0,
-		  const std::vector<T_ts>& ts, double relative_tolerance,
-		  double absolute_tolerance,
-		  long int max_num_steps,  // NOLINT(runtime/int)
-		  std::ostream* msgs, const Args&... args) {
+                  const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_arg,
+                  T_t0 t0, const std::vector<T_ts>& ts,
+                  double relative_tolerance, double absolute_tolerance,
+                  long int max_num_steps,  // NOLINT(runtime/int)
+                  std::ostream* msgs, const Args&... args) {
   using boost::numeric::odeint::integrate_times;
   using boost::numeric::odeint::make_dense_output;
   using boost::numeric::odeint::max_step_checker;
@@ -76,8 +76,7 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
 
   // Code from https://stackoverflow.com/a/17340003
   std::vector<int> unused_temp{
-      0, (check_finite(function_name, "ode parameters and data", args),
-          0)...};
+      0, (check_finite(function_name, "ode parameters and data", args), 0)...};
 
   check_nonzero_size(function_name, "initial state", y0);
   check_nonzero_size(function_name, "times", ts);
@@ -176,15 +175,14 @@ template <typename F, typename T_initial, typename T_t0, typename T_ts,
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, Args...>,
                           Eigen::Dynamic, 1>>
 ode_rk45_tol(const F& f,
-	     const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_arg, T_t0 t0,
-	     const std::vector<T_ts>& ts, double relative_tolerance,
-	     double absolute_tolerance,
-	     long int max_num_steps,  // NOLINT(runtime/int)
-	     std::ostream* msgs, const Args&... args) {
+             const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_arg, T_t0 t0,
+             const std::vector<T_ts>& ts, double relative_tolerance,
+             double absolute_tolerance,
+             long int max_num_steps,  // NOLINT(runtime/int)
+             std::ostream* msgs, const Args&... args) {
   return ode_rk45_tol_impl("ode_rk45_tol", f, y0_arg, t0, ts,
-			   relative_tolerance, absolute_tolerance,
-			   max_num_steps, msgs,
-			   args...);
+                           relative_tolerance, absolute_tolerance,
+                           max_num_steps, msgs, args...);
 }
 
 /**
@@ -231,9 +229,8 @@ ode_rk45(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
   double absolute_tolerance = 1e-10;
   long int max_num_steps = 1e8;  // NOLINT(runtime/int)
 
-  return ode_rk45_tol_impl("ode_rk45",
-			   f, y0, t0, ts, relative_tolerance, absolute_tolerance,
-			   max_num_steps, msgs, args...);
+  return ode_rk45_tol_impl("ode_rk45", f, y0, t0, ts, relative_tolerance,
+                           absolute_tolerance, max_num_steps, msgs, args...);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 37b86acdbd7..14932e412d9 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -187,22 +187,22 @@ class cvodes_integrator {
                     double relative_tolerance, double absolute_tolerance,
                     long int max_num_steps,  // NOLINT(runtime/int)
                     std::ostream* msgs, const T_Args&... args)
-    : function_name_(function_name),
-      f_(f),
-      y0_(y0.unaryExpr([](const T_y0& val) { return T_y0_t0(val); })),
-      t0_(t0),
-      ts_(ts),
-      args_tuple_(args...),
-      value_of_args_tuple_(value_of(args)...),
-      N_(y0.size()),
-      msgs_(msgs),
-      relative_tolerance_(relative_tolerance),
-      absolute_tolerance_(absolute_tolerance),
-      max_num_steps_(max_num_steps),
-      y0_vars_(count_vars(y0_)),
-      args_vars_(count_vars(args...)),
-      coupled_ode_(f, y0_, msgs, args...),
-      coupled_state_(coupled_ode_.initial_state()) {
+      : function_name_(function_name),
+        f_(f),
+        y0_(y0.unaryExpr([](const T_y0& val) { return T_y0_t0(val); })),
+        t0_(t0),
+        ts_(ts),
+        args_tuple_(args...),
+        value_of_args_tuple_(value_of(args)...),
+        N_(y0.size()),
+        msgs_(msgs),
+        relative_tolerance_(relative_tolerance),
+        absolute_tolerance_(absolute_tolerance),
+        max_num_steps_(max_num_steps),
+        y0_vars_(count_vars(y0_)),
+        args_vars_(count_vars(args...)),
+        coupled_ode_(f, y0_, msgs, args...),
+        coupled_state_(coupled_ode_.initial_state()) {
     check_finite(function_name, "initial state", y0_);
     check_finite(function_name, "initial time", t0_);
     check_finite(function_name, "times", ts_);
@@ -212,7 +212,8 @@ class cvodes_integrator {
     apply(
         [&](auto&&... args) {
           std::vector<int> unused_temp{
-              0, (check_finite(function_name, "ode parameters and data", args), 0)...};
+              0, (check_finite(function_name, "ode parameters and data", args),
+                  0)...};
         },
         args_tuple_);
 
@@ -220,8 +221,10 @@ class cvodes_integrator {
     check_nonzero_size(function_name, "initial state", y0_);
     check_sorted(function_name, "times", ts_);
     check_less(function_name, "initial time", t0_, ts_[0]);
-    check_positive_finite(function_name, "relative_tolerance", relative_tolerance_);
-    check_positive_finite(function_name, "absolute_tolerance", absolute_tolerance_);
+    check_positive_finite(function_name, "relative_tolerance",
+                          relative_tolerance_);
+    check_positive_finite(function_name, "absolute_tolerance",
+                          absolute_tolerance_);
     check_positive(function_name, "max_num_steps", max_num_steps_);
 
     nv_state_ = N_VMake_Serial(N_, &coupled_state_[0]);
@@ -299,8 +302,8 @@ class cvodes_integrator {
                           nv_state_sens_),
             "CVodeSensInit");
 
-	check_flag_sundials(CVodeSetSensErrCon(cvodes_mem, SUNTRUE),
-			    "CVodeSetSensErrCon");
+        check_flag_sundials(CVodeSetSensErrCon(cvodes_mem, SUNTRUE),
+                            "CVodeSetSensErrCon");
 
         if (atols.size() > 0) {
           check_positive_finite("cvodes_integrator",
@@ -323,21 +326,22 @@ class cvodes_integrator {
         double t_final = value_of(ts_[n]);
 
         if (t_final != t_init) {
-          int error_code =
-              CVode(cvodes_mem, t_final, nv_state_, &t_init, CV_NORMAL);
-
-	  if (error_code == CV_TOO_MUCH_WORK) {
-	    throw_domain_error(function_name_, "", t_final,
-			       "Failed to integrate to next output time (",
-			       ") in less than max_num_steps steps");
-	  } else {
-	    check_flag_sundials(error_code, "CVode");
-	  }
-
-	  if (y0_vars_ + args_vars_ > 0) {
-	    check_flag_sundials(CVodeGetSens(cvodes_mem, &t_init, nv_state_sens_),
-				"CVodeGetSens");
-	  }
+          int error_code
+              = CVode(cvodes_mem, t_final, nv_state_, &t_init, CV_NORMAL);
+
+          if (error_code == CV_TOO_MUCH_WORK) {
+            throw_domain_error(function_name_, "", t_final,
+                               "Failed to integrate to next output time (",
+                               ") in less than max_num_steps steps");
+          } else {
+            check_flag_sundials(error_code, "CVode");
+          }
+
+          if (y0_vars_ + args_vars_ > 0) {
+            check_flag_sundials(
+                CVodeGetSens(cvodes_mem, &t_init, nv_state_sens_),
+                "CVodeGetSens");
+          }
         }
 
         y.emplace_back(apply(
diff --git a/stan/math/rev/functor/cvodes_utils.hpp b/stan/math/rev/functor/cvodes_utils.hpp
index 17d99bcc630..d747f223959 100644
--- a/stan/math/rev/functor/cvodes_utils.hpp
+++ b/stan/math/rev/functor/cvodes_utils.hpp
@@ -13,7 +13,7 @@ namespace math {
 extern "C" inline void cvodes_err_handler(int error_code, const char* module,
                                           const char* function, char* msg,
                                           void* eh_data) {
-  if(error_code != CV_TOO_MUCH_WORK) {
+  if (error_code != CV_TOO_MUCH_WORK) {
     std::ostringstream msg1;
     msg1 << msg << " Error code: ";
 
diff --git a/stan/math/rev/functor/integrate_ode_adams.hpp b/stan/math/rev/functor/integrate_ode_adams.hpp
index 79ac477a4a2..61e213d43ed 100644
--- a/stan/math/rev/functor/integrate_ode_adams.hpp
+++ b/stan/math/rev/functor/integrate_ode_adams.hpp
@@ -25,10 +25,9 @@ integrate_ode_adams(const F& f, const std::vector<T_initial>& y0,
                     double absolute_tolerance = 1e-10,
                     long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
   internal::integrate_ode_std_vector_interface_adapter<F> f_adapted(f);
-  auto y
-    = ode_adams_tol_impl("integrate_ode_adams",
-			 f_adapted, to_vector(y0), t0, ts, relative_tolerance,
-			 absolute_tolerance, max_num_steps, msgs, theta, x, x_int);
+  auto y = ode_adams_tol_impl("integrate_ode_adams", f_adapted, to_vector(y0),
+                              t0, ts, relative_tolerance, absolute_tolerance,
+                              max_num_steps, msgs, theta, x, x_int);
 
   std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>>
       y_converted;
diff --git a/stan/math/rev/functor/integrate_ode_bdf.hpp b/stan/math/rev/functor/integrate_ode_bdf.hpp
index b97cebd05ca..b8805574538 100644
--- a/stan/math/rev/functor/integrate_ode_bdf.hpp
+++ b/stan/math/rev/functor/integrate_ode_bdf.hpp
@@ -25,9 +25,9 @@ integrate_ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
                   double absolute_tolerance = 1e-10,
                   long int max_num_steps = 1e8) {  // NOLINT(runtime/int)
   internal::integrate_ode_std_vector_interface_adapter<F> f_adapted(f);
-  auto y
-    = ode_bdf_tol_impl("integrate_ode_bdf", f_adapted, to_vector(y0), t0, ts, relative_tolerance,
-		       absolute_tolerance, max_num_steps, msgs, theta, x, x_int);
+  auto y = ode_bdf_tol_impl("integrate_ode_bdf", f_adapted, to_vector(y0), t0,
+                            ts, relative_tolerance, absolute_tolerance,
+                            max_num_steps, msgs, theta, x, x_int);
 
   std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>>
       y_converted;
diff --git a/stan/math/rev/functor/ode_adams.hpp b/stan/math/rev/functor/ode_adams.hpp
index 6f6662a08aa..87f56ce5ece 100644
--- a/stan/math/rev/functor/ode_adams.hpp
+++ b/stan/math/rev/functor/ode_adams.hpp
@@ -46,16 +46,15 @@ template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
-ode_adams_tol_impl(const char* function_name,
-		   const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-		   const T_t0& t0, const std::vector<T_ts>& ts,
-		   double relative_tolerance, double absolute_tolerance,
-		   long int max_num_steps,  // NOLINT(runtime/int)
-		   std::ostream* msgs, const T_Args&... args) {
-  cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator
-    (function_name,
-     f, y0, t0, ts, relative_tolerance, absolute_tolerance,
-     max_num_steps, msgs, args...);
+ode_adams_tol_impl(const char* function_name, const F& f,
+                   const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+                   const T_t0& t0, const std::vector<T_ts>& ts,
+                   double relative_tolerance, double absolute_tolerance,
+                   long int max_num_steps,  // NOLINT(runtime/int)
+                   std::ostream* msgs, const T_Args&... args) {
+  cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
+      function_name, f, y0, t0, ts, relative_tolerance, absolute_tolerance,
+      max_num_steps, msgs, args...);
 
   return integrator();
 }
@@ -102,9 +101,8 @@ ode_adams_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
               double relative_tolerance, double absolute_tolerance,
               long int max_num_steps,  // NOLINT(runtime/int)
               std::ostream* msgs, const T_Args&... args) {
-  return ode_adams_tol_impl("ode_adams_tol",
-			    f, y0, t0, ts, relative_tolerance, absolute_tolerance,
-			    max_num_steps, msgs, args...);
+  return ode_adams_tol_impl("ode_adams_tol", f, y0, t0, ts, relative_tolerance,
+                            absolute_tolerance, max_num_steps, msgs, args...);
 }
 
 /**
@@ -148,10 +146,8 @@ ode_adams(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
   double absolute_tolerance = 1e-10;
   long int max_num_steps = 1e8;  // NOLINT(runtime/int)
 
-  return ode_adams_tol_impl("ode_adams",
-			    f, y0, t0, ts,
-			    relative_tolerance, absolute_tolerance,
-			    max_num_steps, msgs, args...);
+  return ode_adams_tol_impl("ode_adams", f, y0, t0, ts, relative_tolerance,
+                            absolute_tolerance, max_num_steps, msgs, args...);
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 552cb312563..ad7a3f5ea91 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -46,13 +46,14 @@ template <typename F, typename T_initial, typename T_t0, typename T_ts,
           typename... T_Args>
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
-ode_bdf_tol_impl(const char* function_name,
-		 const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-		 const T_t0& t0, const std::vector<T_ts>& ts,
-		 double relative_tolerance, double absolute_tolerance,
-		 long int max_num_steps,  // NOLINT(runtime/int)
-		 std::ostream* msgs, const T_Args&... args) {
-  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(function_name, f, y0, t0, ts, relative_tolerance, absolute_tolerance,
+ode_bdf_tol_impl(const char* function_name, const F& f,
+                 const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+                 const T_t0& t0, const std::vector<T_ts>& ts,
+                 double relative_tolerance, double absolute_tolerance,
+                 long int max_num_steps,  // NOLINT(runtime/int)
+                 std::ostream* msgs, const T_Args&... args) {
+  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
+      function_name, f, y0, t0, ts, relative_tolerance, absolute_tolerance,
       max_num_steps, msgs, args...);
 
   return integrator();
@@ -96,13 +97,12 @@ template <typename F, typename T_initial, typename T_t0, typename T_ts,
 std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
 ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
-	    const T_t0& t0, const std::vector<T_ts>& ts,
-	    double relative_tolerance, double absolute_tolerance,
-	    long int max_num_steps,  // NOLINT(runtime/int)
-	    std::ostream* msgs, const T_Args&... args) {
-  return ode_bdf_tol_impl("ode_bdf_tol", f, y0, t0, ts,
-			  relative_tolerance, absolute_tolerance,
-			  max_num_steps, msgs, args...);
+            const T_t0& t0, const std::vector<T_ts>& ts,
+            double relative_tolerance, double absolute_tolerance,
+            long int max_num_steps,  // NOLINT(runtime/int)
+            std::ostream* msgs, const T_Args&... args) {
+  return ode_bdf_tol_impl("ode_bdf_tol", f, y0, t0, ts, relative_tolerance,
+                          absolute_tolerance, max_num_steps, msgs, args...);
 }
 
 /**
@@ -146,9 +146,8 @@ ode_bdf(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
   double absolute_tolerance = 1e-10;
   long int max_num_steps = 1e8;  // NOLINT(runtime/int)
 
-  return ode_bdf_tol_impl("ode_bdf", f, y0, t0, ts,
-			  relative_tolerance, absolute_tolerance,
-			  max_num_steps, msgs, args...);
+  return ode_bdf_tol_impl("ode_bdf", f, y0, t0, ts, relative_tolerance,
+                          absolute_tolerance, max_num_steps, msgs, args...);
 }
 
 }  // namespace math
diff --git a/test/unit/math/prim/functor/coupled_ode_system_test.cpp b/test/unit/math/prim/functor/coupled_ode_system_test.cpp
index 7560596779a..e7f2d41aa5b 100644
--- a/test/unit/math/prim/functor/coupled_ode_system_test.cpp
+++ b/test/unit/math/prim/functor/coupled_ode_system_test.cpp
@@ -28,8 +28,9 @@ TEST_F(StanMathOde, initial_state_dd) {
   for (int m = 0; m < M; m++)
     theta_d[m] = 10 * (m + 1);
 
-  coupled_ode_system<mock_ode_functor, double, std::vector<double>, std::vector<double>, std::vector<int>> coupled_system_dd(
-      base_ode, y0_d, &msgs, theta_d, x, x_int);
+  coupled_ode_system<mock_ode_functor, double, std::vector<double>,
+                     std::vector<double>, std::vector<int>>
+      coupled_system_dd(base_ode, y0_d, &msgs, theta_d, x, x_int);
 
   Eigen::VectorXd state = coupled_system_dd.initial_state();
   for (int n = 0; n < N; n++)
@@ -50,9 +51,8 @@ TEST_F(StanMathOde, size) {
   Eigen::VectorXd y0_d(N);
   std::vector<double> theta_d(M, 0.0);
 
-  coupled_ode_system<mock_ode_functor, double,
-		     int, double,
-		     Eigen::MatrixXd> coupled_system_dd(base_ode, y0_d, &msgs, 1, 1.0, y0_d);
+  coupled_ode_system<mock_ode_functor, double, int, double, Eigen::MatrixXd>
+      coupled_system_dd(base_ode, y0_d, &msgs, 1, 1.0, y0_d);
 
   EXPECT_EQ(N, coupled_system_dd.size());
 }
@@ -80,4 +80,3 @@ TEST_F(StanMathOde, recover_exception) {
 
   EXPECT_THROW_MSG(coupled_system_dd(y, dy_dt, t), std::logic_error, message);
 }
-
diff --git a/test/unit/math/prim/functor/mock_ode_functor.hpp b/test/unit/math/prim/functor/mock_ode_functor.hpp
index 6c95e951c6b..14346e227cc 100644
--- a/test/unit/math/prim/functor/mock_ode_functor.hpp
+++ b/test/unit/math/prim/functor/mock_ode_functor.hpp
@@ -4,10 +4,8 @@ struct mock_ode_functor {
   template <typename T0, typename T1, typename T2, typename T3, typename T4>
   inline Eigen::Matrix<stan::return_type_t<T1, T2, T3, T4>, Eigen::Dynamic, 1>
   operator()(const T0& t_in, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y_in,
-	     std::ostream* msgs,
-	     const T2& a1,
-	     const T3& a2,
-	     const T4& a3) const {
+             std::ostream* msgs, const T2& a1, const T3& a2,
+             const T4& a3) const {
     return y_in.template cast<stan::return_type_t<T1, T2, T3, T4>>();
   }
 };
diff --git a/test/unit/math/prim/functor/mock_throwing_ode_functor.hpp b/test/unit/math/prim/functor/mock_throwing_ode_functor.hpp
index cf37d5fdaab..cd1b2d54a35 100644
--- a/test/unit/math/prim/functor/mock_throwing_ode_functor.hpp
+++ b/test/unit/math/prim/functor/mock_throwing_ode_functor.hpp
@@ -18,12 +18,10 @@ struct mock_throwing_ode_functor {
 
   template <typename T0, typename T1, typename T2>
   inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1>
-  operator()(const T0& t_in,
-	     const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y_in,
-	     std::ostream* msgs,
-	     const std::vector<T2>& theta,
-	     const std::vector<double>& x,
-	     const std::vector<int>& x_int) const {
+  operator()(const T0& t_in, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y_in,
+             std::ostream* msgs, const std::vector<T2>& theta,
+             const std::vector<double>& x,
+             const std::vector<int>& x_int) const {
     mock_throwing_ode_functor_count++;
     if (N_ == mock_throwing_ode_functor_count)
       throw E(msg_);
diff --git a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
index 22564ec9d7f..c4bf567f641 100644
--- a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
@@ -248,5 +248,5 @@ TEST(ode_rk45_prim, error_name) {
   double ainf = stan::math::INFTY;
 
   EXPECT_THROW_MSG(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, ainf),
-		   std::domain_error, "ode_rk45");
+                   std::domain_error, "ode_rk45");
 }
diff --git a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
index 6c8c4d689fe..eccfae12b94 100644
--- a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
@@ -358,7 +358,7 @@ TEST(ode_rk45_tol_prim, error_name) {
 
   double ainf = stan::math::INFTY;
 
-  EXPECT_THROW_MSG(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6, 100,
-					nullptr, ainf),
-               std::domain_error, "ode_rk45_tol");
+  EXPECT_THROW_MSG(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                            100, nullptr, ainf),
+                   std::domain_error, "ode_rk45_tol");
 }
diff --git a/test/unit/math/rev/functor/ode_adams_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
index 678ce544610..84b30e17612 100644
--- a/test/unit/math/rev/functor/ode_adams_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
@@ -247,7 +247,6 @@ TEST(ode_adams_prim, error_name) {
 
   double ainf = stan::math::INFTY;
 
-  EXPECT_THROW_MSG(stan::math::ode_adams(CosArg1(), y0, t0, ts,
-					nullptr, ainf),
-               std::domain_error, "ode_adams");
+  EXPECT_THROW_MSG(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, ainf),
+                   std::domain_error, "ode_adams");
 }
diff --git a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
index a1e65568be6..e3eca2644b8 100644
--- a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
@@ -358,7 +358,7 @@ TEST(ode_adams_tol_prim, error_name) {
 
   double ainf = stan::math::INFTY;
 
-  EXPECT_THROW_MSG(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6, 100,
-					nullptr, ainf),
-               std::domain_error, "ode_adams_tol");
+  EXPECT_THROW_MSG(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                             100, nullptr, ainf),
+                   std::domain_error, "ode_adams_tol");
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index 75c3a3d2d33..b94f1cb8b6d 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -248,5 +248,5 @@ TEST(ode_bdf_prim, error_name) {
   double ainf = stan::math::INFTY;
 
   EXPECT_THROW_MSG(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, ainf),
-		   std::domain_error, "ode_bdf");
+                   std::domain_error, "ode_bdf");
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
index 364b5a62d1d..110298e5512 100644
--- a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
@@ -359,6 +359,6 @@ TEST(ode_bdf_tol_prim, error_name) {
   double ainf = stan::math::INFTY;
 
   EXPECT_THROW_MSG(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-					   100, nullptr, ainf),
-		   std::domain_error, "ode_bdf_tol");
+                                           100, nullptr, ainf),
+                   std::domain_error, "ode_bdf_tol");
 }

From 9592cba059ec1cfbb395615ebdc395f56e12705e Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Tue, 30 Jun 2020 17:23:58 -0400
Subject: [PATCH 147/189] Added more time points to ode prim tests (design-doc
 #19)

---
 test/unit/math/prim/functor/ode_rk45_prim_test.cpp     | 4 ++++
 test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp | 4 ++++
 test/unit/math/rev/functor/ode_adams_prim_test.cpp     | 4 ++++
 test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp | 4 ++++
 test/unit/math/rev/functor/ode_bdf_prim_test.cpp       | 4 ++++
 test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp   | 4 ++++
 6 files changed, 24 insertions(+)

diff --git a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
index c4bf567f641..c23ae5e96e0 100644
--- a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
@@ -107,6 +107,7 @@ TEST(ode_rk45_prim, ts_errors) {
   double t0 = 0;
   std::vector<double> ts = {0.45, 1.1};
   std::vector<double> ts_repeat = {0.45, 0.45};
+  std::vector<double> ts_lots = {0.45, 0.45, 1.1, 1.1, 2.0};
   std::vector<double> ts_empty = {};
   std::vector<double> ts_early = {-0.45, 0.2};
   std::vector<double> ts_decreasing = {0.45, 0.2};
@@ -120,6 +121,9 @@ TEST(ode_rk45_prim, ts_errors) {
   EXPECT_NO_THROW(
       stan::math::ode_rk45(CosArg1(), y0, t0, ts_repeat, nullptr, a));
 
+  EXPECT_NO_THROW(
+      stan::math::ode_rk45(CosArg1(), y0, t0, ts_lots, nullptr, a));
+
   EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts_empty, nullptr, a),
                std::invalid_argument);
 
diff --git a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
index eccfae12b94..cb156121467 100644
--- a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
@@ -114,6 +114,7 @@ TEST(ode_rk45_tol_prim, ts_errors) {
   double t0 = 0;
   std::vector<double> ts = {0.45, 1.1};
   std::vector<double> ts_repeat = {0.45, 0.45};
+  std::vector<double> ts_lots = {0.45, 0.45, 1.1, 1.1, 2.0};
   std::vector<double> ts_empty = {};
   std::vector<double> ts_early = {-0.45, 0.2};
   std::vector<double> ts_decreasing = {0.45, 0.2};
@@ -128,6 +129,9 @@ TEST(ode_rk45_tol_prim, ts_errors) {
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
                                            1e-10, 1e6, nullptr, a));
 
+    EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
+                                           1e-10, 1e6, nullptr, a));
+
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
                                         1e-10, 1e6, nullptr, a),
                std::invalid_argument);
diff --git a/test/unit/math/rev/functor/ode_adams_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
index 84b30e17612..754e558fd34 100644
--- a/test/unit/math/rev/functor/ode_adams_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
@@ -107,6 +107,7 @@ TEST(ode_adams_prim, ts_errors) {
   double t0 = 0;
   std::vector<double> ts = {0.45, 1.1};
   std::vector<double> ts_repeat = {0.45, 0.45};
+  std::vector<double> ts_lots = {0.45, 0.45, 1.1, 1.1, 2.0};
   std::vector<double> ts_empty = {};
   std::vector<double> ts_early = {-0.45, 0.2};
   std::vector<double> ts_decreasing = {0.45, 0.2};
@@ -120,6 +121,9 @@ TEST(ode_adams_prim, ts_errors) {
   EXPECT_NO_THROW(
       stan::math::ode_adams(CosArg1(), y0, t0, ts_repeat, nullptr, a));
 
+  EXPECT_NO_THROW(
+      stan::math::ode_adams(CosArg1(), y0, t0, ts_lots, nullptr, a));
+
   EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts_empty, nullptr, a),
                std::invalid_argument);
 
diff --git a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
index e3eca2644b8..39ddfd74534 100644
--- a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
@@ -114,6 +114,7 @@ TEST(ode_adams_tol_prim, ts_errors) {
   double t0 = 0;
   std::vector<double> ts = {0.45, 1.1};
   std::vector<double> ts_repeat = {0.45, 0.45};
+  std::vector<double> ts_lots = {0.45, 0.45, 1.1, 1.1, 2.0};
   std::vector<double> ts_empty = {};
   std::vector<double> ts_early = {-0.45, 0.2};
   std::vector<double> ts_decreasing = {0.45, 0.2};
@@ -128,6 +129,9 @@ TEST(ode_adams_tol_prim, ts_errors) {
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
                                             1e-10, 1e6, nullptr, a));
 
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
+                                            1e-10, 1e6, nullptr, a));
+
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
                                          1e-10, 1e6, nullptr, a),
                std::invalid_argument);
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index b94f1cb8b6d..8f39d5e4843 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -107,6 +107,7 @@ TEST(ode_bdf_prim, ts_errors) {
   double t0 = 0;
   std::vector<double> ts = {0.45, 1.1};
   std::vector<double> ts_repeat = {0.45, 0.45};
+  std::vector<double> ts_lots = {0.45, 0.45, 1.1, 1.1, 2.0};
   std::vector<double> ts_empty = {};
   std::vector<double> ts_early = {-0.45, 0.2};
   std::vector<double> ts_decreasing = {0.45, 0.2};
@@ -120,6 +121,9 @@ TEST(ode_bdf_prim, ts_errors) {
   EXPECT_NO_THROW(
       stan::math::ode_bdf(CosArg1(), y0, t0, ts_repeat, nullptr, a));
 
+  EXPECT_NO_THROW(
+      stan::math::ode_bdf(CosArg1(), y0, t0, ts_lots, nullptr, a));
+
   EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts_empty, nullptr, a),
                std::invalid_argument);
 
diff --git a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
index 110298e5512..cc7139e0b13 100644
--- a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
@@ -114,6 +114,7 @@ TEST(ode_bdf_tol_prim, ts_errors) {
   double t0 = 0;
   std::vector<double> ts = {0.45, 1.1};
   std::vector<double> ts_repeat = {0.45, 0.45};
+  std::vector<double> ts_lots = {0.45, 0.45, 1.1, 1.1, 2.0};
   std::vector<double> ts_empty = {};
   std::vector<double> ts_early = {-0.45, 0.2};
   std::vector<double> ts_decreasing = {0.45, 0.2};
@@ -128,6 +129,9 @@ TEST(ode_bdf_tol_prim, ts_errors) {
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
                                           1e-10, 1e6, nullptr, a));
 
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
+                                          1e-10, 1e6, nullptr, a));
+
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
                                        1e-10, 1e6, nullptr, a),
                std::invalid_argument);

From d4f8fe1c11640d27fb0495988c77afe0ffa76071 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Tue, 30 Jun 2020 22:22:49 -0400
Subject: [PATCH 148/189] Updated docs, cleaned up template naming, avoided
 unncessary nested adjoint stack zeroing, updated default rk45 tolerances, got
 rid of unnecessary argument tuple, changed how some casts were done, and
 removed some experimental error tolerance stuff.

(design-doc #19)
---
 stan/math/prim/functor/coupled_ode_system.hpp | 104 ++++++------------
 stan/math/prim/functor/integrate_ode_rk45.hpp |   8 +-
 stan/math/prim/functor/ode_rk45.hpp           |  38 +++----
 .../prim/functor/ode_store_sensitivities.hpp  |   8 +-
 stan/math/rev/functor/coupled_ode_system.hpp  |  56 +++++-----
 stan/math/rev/functor/cvodes_integrator.hpp   |  27 +----
 stan/math/rev/functor/integrate_ode_adams.hpp |   8 +-
 stan/math/rev/functor/integrate_ode_bdf.hpp   |   8 +-
 stan/math/rev/functor/ode_adams.hpp           |  20 ++--
 stan/math/rev/functor/ode_bdf.hpp             |  20 ++--
 .../rev/functor/ode_store_sensitivities.hpp   |  10 +-
 11 files changed, 121 insertions(+), 186 deletions(-)

diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
index a00b78bb333..c154726b07e 100644
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -11,60 +11,21 @@
 namespace stan {
 namespace math {
 
+template <bool Enable, typename F, typename T_y0, typename... Args>
+struct coupled_ode_system_impl;
+
 /**
- * The <code>coupled_ode_system</code> template specialization
- * for unknown initial values and unknown parameters.
- *
- * <p>This coupled ode system has N + (N +  M) * N states where N is
- * the size of the base ode system and M is the number of parameters.
- *
- * <p>For the coupled ode system, the first N states are the base
- * system's states: \f$ \frac{d x_n}{dt} \f$.
- *
- * <p>The next N + M states correspond to the sensitivities of the
- * initial conditions, then to the sensitivities of the parameters
- * with respect to the to the first base system equation:
- *
- * \f[
- *   \frac{d x_{N + n}}{dt}
- *     = \frac{d}{dt} \frac{\partial x_1}{\partial y0_n}
- * \f]
- *
- * \f[
- *   \frac{d x_{N + N + m}}{dt}
- *     = \frac{d}{dt} \frac{\partial x_1}{\partial \theta_m}
- * \f]
- *
- * <p>The next N + M states correspond to the sensitivities
- * of the initial conditions followed by the sensitivites of the
- * parameters with respect to the second base system equation, and
- * so on through the last base system equation.
- *
- * <p>Note: Calculating the sensitivity system requires the Jacobian
- * of the base ODE RHS wrt to the parameters theta. The parameter
- * vector theta is constant for successive calls to the exposed
- * operator(). For this reason, the parameter vector theta is copied
- * upon construction onto the nochain var autodiff tape which is used
- * in the the nested autodiff performed in the operator() of this
- * adaptor. Doing so reduces the size of the nested autodiff and
- * speeds up autodiff. As a side effect, the parameter vector theta
- * will remain on the nochain autodiff part of the autodiff tape being
- * in use even after destruction of the given instance. Moreover, the
- * adjoint zeroing for the nested system does not cover the theta
- * parameter vector part of the nochain autodiff tape and is therefore
- * set to zero using a dedicated loop.
+ * The <code>coupled_ode_system_impl</code> for arithmetic types reduces to
+ * the regular ode system (there are no sensitivities)
  *
  * @tparam F base ode system functor. Must provide
- *   <code>operator()(double t, std::vector<var> y, std::vector<var> theta,
- *          std::vector<double> x, std::vector<int>x_int, std::ostream*
- * msgs)</code>
+ *   <code>
+ *     template<typename T_y, typename... T_args>
+ *     operator()(double t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
+ *     std::ostream* msgs, const T_args&... args)</code>
  */
-
-template <bool Enable, typename F, typename T_initial, typename... Args>
-struct coupled_ode_system_impl;
-
-template <typename F, typename T_initial, typename... Args>
-struct coupled_ode_system_impl<true, F, T_initial, Args...> {
+template <typename F, typename T_y0, typename... Args>
+struct coupled_ode_system_impl<true, F, T_y0, Args...> {
   const F& f_;
   const Eigen::VectorXd& y0_;
   std::tuple<const Args&...> args_tuple_;
@@ -85,7 +46,18 @@ struct coupled_ode_system_impl<true, F, T_initial, Args...> {
                           std::ostream* msgs, const Args&... args)
       : f_(f), y0_(y0), args_tuple_(args...), N_(y0.size()), msgs_(msgs) {}
 
-  void operator()(const std::vector<double>& z, std::vector<double>& dy_dt,
+  /**
+   * Evaluate the right hand side of the coupled system at state z and time t,
+   * and store the sensitivities in dz_dt.
+   *
+   * For all arithmetic types the coupled system right hand side is the same
+   * as the regular ODE right hand side.
+   *
+   * @param[in] z State of coupled system
+   * @param[out] dz_dt Evaluation of right hand side of coupled system
+   * @param[in] t Time at which to evaluated right hand side
+   */
+  void operator()(const std::vector<double>& z, std::vector<double>& dz_dt,
                   double t) const {
     Eigen::VectorXd y(N_);
     for (size_t n = 0; n < N_; ++n)
@@ -111,22 +83,10 @@ struct coupled_ode_system_impl<true, F, T_initial, Args...> {
   size_t size() const { return N_; }
 
   /**
-   * Returns the initial state of the coupled system.
-   *
-   * <p>Because the starting state is unknown, the coupled system
-   * incorporates the initial conditions as parameters. At the initial
-   * time the Jacobian of the integrated function is the identity
-   * matrix. In addition the coupled system includes the Jacobian of
-   * the integrated function wrt to the parameters. This Jacobian is
-   * zero at the initial time-point.
+   * Returns the initial state of the coupled system. For arithmetic types
+   * this is the same as the regular ode system.
    *
-   * @return the initial condition of the coupled system.  This is a
-   *   vector of length size() where the first N values are the
-   *   initial condition of the base ODE and the next N*N elements
-   *   correspond to the identity matrix which is the Jacobian of the
-   *   integrated function at the initial time-point. The last N*M
-   *   elements are all zero as these are the Jacobian wrt to the
-   *   parameters at the initial time-point, which is zero.
+   * @return the initial condition of the coupled system
    */
   std::vector<double> initial_state() const {
     std::vector<double> initial(size(), 0.0);
@@ -139,17 +99,17 @@ struct coupled_ode_system_impl<true, F, T_initial, Args...> {
   }
 };
 
-template <typename F, typename T_initial, typename... Args>
+template <typename F, typename T_y0, typename... Args>
 struct coupled_ode_system
     : public coupled_ode_system_impl<
-          std::is_arithmetic<return_type_t<T_initial, Args...>>::value, F,
-          T_initial, Args...> {
+          std::is_arithmetic<return_type_t<T_y0, Args...>>::value, F,
+          T_y0, Args...> {
   coupled_ode_system(const F& f,
-                     const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+                     const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
                      std::ostream* msgs, const Args&... args)
       : coupled_ode_system_impl<
-            std::is_arithmetic<return_type_t<T_initial, Args...>>::value, F,
-            T_initial, Args...>(f, y0, msgs, args...) {}
+            std::is_arithmetic<return_type_t<T_y0, Args...>>::value, F,
+            T_y0, Args...>(f, y0, msgs, args...) {}
 };
 
 }  // namespace math
diff --git a/stan/math/prim/functor/integrate_ode_rk45.hpp b/stan/math/prim/functor/integrate_ode_rk45.hpp
index 78a061fdd0b..50686b2396c 100644
--- a/stan/math/prim/functor/integrate_ode_rk45.hpp
+++ b/stan/math/prim/functor/integrate_ode_rk45.hpp
@@ -13,10 +13,10 @@ namespace math {
 /**
  * @deprecated use <code>ode_rk45</code>
  */
-template <typename F, typename T1, typename T_param, typename T_t0,
+template <typename F, typename T_y0, typename T_param, typename T_t0,
           typename T_ts>
-std::vector<std::vector<return_type_t<T1, T_t0, T_ts, T_param>>>
-integrate_ode_rk45(const F& f, const std::vector<T1>& y0, const T_t0& t0,
+std::vector<std::vector<return_type_t<T_y0, T_t0, T_ts, T_param>>>
+integrate_ode_rk45(const F& f, const std::vector<T_y0>& y0, const T_t0& t0,
                    const std::vector<T_ts>& ts,
                    const std::vector<T_param>& theta,
                    const std::vector<double>& x, const std::vector<int>& x_int,
@@ -28,7 +28,7 @@ integrate_ode_rk45(const F& f, const std::vector<T1>& y0, const T_t0& t0,
                              ts, relative_tolerance, absolute_tolerance,
                              max_num_steps, msgs, theta, x, x_int);
 
-  std::vector<std::vector<return_type_t<T1, T_param, T_t0, T_ts>>> y_converted;
+  std::vector<std::vector<return_type_t<T_y0, T_param, T_t0, T_ts>>> y_converted;
   for (size_t i = 0; i < y.size(); ++i)
     y_converted.push_back(to_array_1d(y[i]));
 
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index d8276fa613c..9126c33f4ee 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -32,7 +32,8 @@ namespace math {
  * through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
- * @tparam T_0 Type of initial time
+ * @tparam T_y0 Type of initial condition
+ * @tparam T_t0 Type of initial time
  * @tparam T_ts Type of output times
  * @tparam T_Args Types of pass-through parameters
  *
@@ -49,12 +50,12 @@ namespace math {
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return Solution to ODE at times \p ts
  */
-template <typename F, typename T_initial, typename T_t0, typename T_ts,
+template <typename F, typename T_y0, typename T_t0, typename T_ts,
           typename... Args>
-std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, Args...>,
+std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, Args...>,
                           Eigen::Dynamic, 1>>
 ode_rk45_tol_impl(const char* function_name, const F& f,
-                  const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_arg,
+                  const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0_arg,
                   T_t0 t0, const std::vector<T_ts>& ts,
                   double relative_tolerance, double absolute_tolerance,
                   long int max_num_steps,  // NOLINT(runtime/int)
@@ -65,10 +66,9 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
   using boost::numeric::odeint::runge_kutta_dopri5;
   using boost::numeric::odeint::vector_space_algebra;
 
-  using T_initial_or_t0 = return_type_t<T_initial, T_t0>;
+  using T_y0_t0 = return_type_t<T_y0, T_t0>;
 
-  Eigen::Matrix<T_initial_or_t0, Eigen::Dynamic, 1> y0 = y0_arg.unaryExpr(
-      [](const T_initial& val) { return T_initial_or_t0(val); });
+  Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1> y0 = y0_arg.template cast<T_y0_t0>();
 
   check_finite(function_name, "initial state", y0);
   check_finite(function_name, "initial time", t0);
@@ -89,9 +89,9 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
                         absolute_tolerance);
   check_positive(function_name, "max_num_steps", max_num_steps);
 
-  using return_t = return_type_t<T_initial, T_t0, T_ts, Args...>;
+  using return_t = return_type_t<T_y0, T_t0, T_ts, Args...>;
   // creates basic or coupled system by template specializations
-  coupled_ode_system<F, T_initial_or_t0, Args...> coupled_system(f, y0, msgs,
+  coupled_ode_system<F, T_y0_t0, Args...> coupled_system(f, y0, msgs,
                                                                  args...);
 
   // first time in the vector must be time of initial state
@@ -170,12 +170,12 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return Solution to ODE at times \p ts
  */
-template <typename F, typename T_initial, typename T_t0, typename T_ts,
+template <typename F, typename T_y0, typename T_t0, typename T_ts,
           typename... Args>
-std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, Args...>,
+std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, Args...>,
                           Eigen::Dynamic, 1>>
 ode_rk45_tol(const F& f,
-             const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_arg, T_t0 t0,
+             const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0_arg, T_t0 t0,
              const std::vector<T_ts>& ts, double relative_tolerance,
              double absolute_tolerance,
              long int max_num_steps,  // NOLINT(runtime/int)
@@ -205,7 +205,7 @@ ode_rk45_tol(const F& f,
  * through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
- * @tparam T_0 Type of initial time
+ * @tparam T_y0 Type of initial time
  * @tparam T_ts Type of output times
  * @tparam T_Args Types of pass-through parameters
  *
@@ -218,16 +218,16 @@ ode_rk45_tol(const F& f,
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return Solution to ODE at times \p ts
  */
-template <typename F, typename T_initial, typename T_t0, typename T_ts,
+template <typename F, typename T_y0, typename T_t0, typename T_ts,
           typename... Args>
-std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, Args...>,
+std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, Args...>,
                           Eigen::Dynamic, 1>>
-ode_rk45(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+ode_rk45(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
          T_t0 t0, const std::vector<T_ts>& ts, std::ostream* msgs,
          const Args&... args) {
-  double relative_tolerance = 1e-10;
-  double absolute_tolerance = 1e-10;
-  long int max_num_steps = 1e8;  // NOLINT(runtime/int)
+  double relative_tolerance = 1e-6;
+  double absolute_tolerance = 1e-6;
+  long int max_num_steps = 1e6;  // NOLINT(runtime/int)
 
   return ode_rk45_tol_impl("ode_rk45", f, y0, t0, ts, relative_tolerance,
                            absolute_tolerance, max_num_steps, msgs, args...);
diff --git a/stan/math/prim/functor/ode_store_sensitivities.hpp b/stan/math/prim/functor/ode_store_sensitivities.hpp
index bdab74da3be..82a0969aabb 100644
--- a/stan/math/prim/functor/ode_store_sensitivities.hpp
+++ b/stan/math/prim/functor/ode_store_sensitivities.hpp
@@ -9,10 +9,14 @@ namespace stan {
 namespace math {
 
 /**
- * Build output for state of ODE solve from the current coupled_state when
- * all arguments are arithmetic.
+ * When all arguments are arithmetic, there are no sensitivities to store, so
+ *  the function just returns the current coupled_state.
  *
  * @tparam F Type of ODE right hand side
+ * @tparam T_y0_t0 Type of initial state
+ * @tparam T_t0 Type of initial time
+ * @tparam T_ts Type of output times
+ * @tparam T_Args Types of pass-through parameters
  *
  * @param f Right hand side of the ODE
  * @param coupled_state Current state of the coupled_ode_system
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index f4f1f4df9bd..1b09de8ef2f 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -15,7 +15,7 @@ namespace stan {
 namespace math {
 
 /**
- * The <code>coupled_ode_system</code> template specialization
+ * The <code>coupled_ode_system_impl</code> template specialization
  * for unknown initial values and unknown parameters.
  *
  * <p>This coupled ode system has N + (N +  M) * N states where N is
@@ -26,7 +26,8 @@ namespace math {
  *
  * <p>The next N + M states correspond to the sensitivities of the
  * initial conditions, then to the sensitivities of the parameters
- * with respect to the to the first base system equation:
+ * with respect to the to the first base system equation. Calling
+ * initial conditions \f$ y0 \f$ and parameters \f$ \theta \f$:
  *
  * \f[
  *   \frac{d x_{N + n}}{dt}
@@ -44,29 +45,28 @@ namespace math {
  * so on through the last base system equation.
  *
  * <p>Note: Calculating the sensitivity system requires the Jacobian
- * of the base ODE RHS wrt to the parameters theta. The parameter
- * vector theta is constant for successive calls to the exposed
- * operator(). For this reason, the parameter vector theta is copied
- * upon construction onto the nochain var autodiff tape which is used
- * in the the nested autodiff performed in the operator() of this
- * adaptor. Doing so reduces the size of the nested autodiff and
- * speeds up autodiff. As a side effect, the parameter vector theta
+ * of the base ODE RHS wrt to the parameters. The parameters are constant
+ * for successive calls to the exposed operator(). For this reason,
+ * the parameter vector theta is copied upon construction onto the nochain
+ * var autodiff tape which is used in the the nested autodiff performed
+ * in the operator() of this adaptor. Doing so reduces the size of the
+ * nested autodiff and speeds up autodiff. As a side effect, the parameters
  * will remain on the nochain autodiff part of the autodiff tape being
  * in use even after destruction of the given instance. Moreover, the
  * adjoint zeroing for the nested system does not cover the theta
  * parameter vector part of the nochain autodiff tape and is therefore
- * set to zero using a dedicated loop.
+ * set to zero separately.
  *
  * @tparam F base ode system functor. Must provide
- *   <code>operator()(double t, std::vector<var> y, std::vector<var> theta,
- *          std::vector<double> x, std::vector<int>x_int, std::ostream*
- * msgs)</code>
+ *   <code>
+ *     template<typename T_y, typename... T_args>
+ *     operator()(double t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
+ *     std::ostream* msgs, const T_args&... args)</code>
  */
-template <typename F, typename T_initial, typename... Args>
-struct coupled_ode_system_impl<false, F, T_initial, Args...> {
+template <typename F, typename T_y0, typename... Args>
+struct coupled_ode_system_impl<false, F, T_y0, Args...> {
   const F& f_;
-  const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0_;
-  std::tuple<const Args&...> args_tuple_;
+  const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0_;
   std::tuple<decltype(deep_copy_vars(std::declval<Args>()))...>
       local_args_tuple_;
   const size_t y0_vars_;
@@ -87,11 +87,10 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
    * @param[in] args other additional arguments
    */
   coupled_ode_system_impl(const F& f,
-                          const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+                          const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
                           std::ostream* msgs, const Args&... args)
       : f_(f),
         y0_(y0),
-        args_tuple_(args...),
         local_args_tuple_(deep_copy_vars(args)...),
         y0_vars_(count_vars(y0_)),
         args_vars_(count_vars(args...)),
@@ -128,8 +127,8 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
   }
 
   /**
-   * Calculates the derivative of the coupled ode system with respect
-   * to time.
+   * Calculates the right hand side of the coupled ode system (the regular
+   * ode system with forward sensitivities).
    *
    * This method uses nested autodiff and is not thread safe.
    *
@@ -150,11 +149,6 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
     // Run nested autodiff in this scope
     nested_rev_autodiff nested;
 
-    /*auto local_args_tuple_ = apply([&](auto&&... args) {
-        return
-       std::tuple<decltype(deep_copy_vars(args))...>(deep_copy_vars(args)...);
-        }, args_tuple_);*/
-
     Eigen::Matrix<var, Eigen::Dynamic, 1> y_vars(N_);
     for (size_t n = 0; n < N_; ++n)
       y_vars.coeffRef(n) = z[n];
@@ -180,14 +174,14 @@ struct coupled_ode_system_impl<false, F, T_initial, Args...> {
           local_args_tuple_);
 
       apply([&](auto&&... args) { zero_local_adjoints(args...); },
-            local_args_tuple_);
+	    local_args_tuple_);
 
-      nested.set_zero_all_adjoints();
+      // No need to zero adjoints after last sweep
+      if(i < N_) {
+	nested.set_zero_all_adjoints();
+      }
 
       for (size_t j = 0; j < y0_vars_; ++j) {
-        // orders derivatives by equation (i.e. if there are 2 eqns
-        // (y1, y2) and 2 parameters (a, b), dy_dt will be ordered as:
-        // dy1_dt, dy2_dt, dy1_da, dy2_da, dy1_db, dy2_db
         double temp_deriv = 0.0;
         for (size_t k = 0; k < N_; ++k) {
           temp_deriv += z[N_ + N_ * j + k] * y_adjoints_.coeffRef(k);
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 14932e412d9..10930b13b30 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -189,7 +189,7 @@ class cvodes_integrator {
                     std::ostream* msgs, const T_Args&... args)
       : function_name_(function_name),
         f_(f),
-        y0_(y0.unaryExpr([](const T_y0& val) { return T_y0_t0(val); })),
+        y0_(y0.template cast<T_y0_t0>()),
         t0_(t0),
         ts_(ts),
         args_tuple_(args...),
@@ -259,11 +259,6 @@ class cvodes_integrator {
    *   solution time (excluding the initial state)
    */
   std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> operator()() {
-    return (*this)(0.0, {});
-  }
-
-  std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> operator()(
-      double rtols, std::vector<double> atols) {
     std::vector<Eigen::Matrix<T_Return, Eigen::Dynamic, 1>> y;
 
     void* cvodes_mem = CVodeCreate(Lmm);
@@ -284,10 +279,6 @@ class cvodes_integrator {
       cvodes_set_options(cvodes_mem, relative_tolerance_, absolute_tolerance_,
                          max_num_steps_);
 
-      // for the stiff solvers we need to reserve additional memory
-      // and provide a Jacobian function call. new API since 3.0.0:
-      // create matrix object and linear solver object; resource
-      // (de-)allocation is handled in the cvodes_ode_data
       check_flag_sundials(CVodeSetLinearSolver(cvodes_mem, LS_, A_),
                           "CVodeSetLinearSolver");
       check_flag_sundials(
@@ -305,20 +296,8 @@ class cvodes_integrator {
         check_flag_sundials(CVodeSetSensErrCon(cvodes_mem, SUNTRUE),
                             "CVodeSetSensErrCon");
 
-        if (atols.size() > 0) {
-          check_positive_finite("cvodes_integrator",
-                                "sensitivity relative_tolerance", rtols);
-          check_size_match("cvodes_interator", "atols.size()", atols.size(),
-                           "number of sensitivities", y0_vars_ + args_vars_);
-          check_positive_finite("cvodes_integrator",
-                                "sensitivity absolute_tolerance", atols);
-          check_flag_sundials(
-              CVodeSensSStolerances(cvodes_mem, rtols, atols.data()),
-              "CVodeSensSStolerances");
-        } else {
-          check_flag_sundials(CVodeSensEEtolerances(cvodes_mem),
-                              "CVodeSensEEtolerances");
-        }
+	check_flag_sundials(CVodeSensEEtolerances(cvodes_mem),
+			    "CVodeSensEEtolerances");
       }
 
       double t_init = value_of(t0_);
diff --git a/stan/math/rev/functor/integrate_ode_adams.hpp b/stan/math/rev/functor/integrate_ode_adams.hpp
index 61e213d43ed..77421c006a7 100644
--- a/stan/math/rev/functor/integrate_ode_adams.hpp
+++ b/stan/math/rev/functor/integrate_ode_adams.hpp
@@ -13,10 +13,10 @@ namespace math {
 /**
  *  @deprecated use <code>ode_adams</code>
  */
-template <typename F, typename T_initial, typename T_param, typename T_t0,
+template <typename F, typename T_y0, typename T_param, typename T_t0,
           typename T_ts>
-std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>>
-integrate_ode_adams(const F& f, const std::vector<T_initial>& y0,
+std::vector<std::vector<return_type_t<T_y0, T_param, T_t0, T_ts>>>
+integrate_ode_adams(const F& f, const std::vector<T_y0>& y0,
                     const T_t0& t0, const std::vector<T_ts>& ts,
                     const std::vector<T_param>& theta,
                     const std::vector<double>& x, const std::vector<int>& x_int,
@@ -29,7 +29,7 @@ integrate_ode_adams(const F& f, const std::vector<T_initial>& y0,
                               t0, ts, relative_tolerance, absolute_tolerance,
                               max_num_steps, msgs, theta, x, x_int);
 
-  std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>>
+  std::vector<std::vector<return_type_t<T_y0, T_param, T_t0, T_ts>>>
       y_converted;
   for (size_t i = 0; i < y.size(); ++i)
     y_converted.push_back(to_array_1d(y[i]));
diff --git a/stan/math/rev/functor/integrate_ode_bdf.hpp b/stan/math/rev/functor/integrate_ode_bdf.hpp
index b8805574538..c3877bdb875 100644
--- a/stan/math/rev/functor/integrate_ode_bdf.hpp
+++ b/stan/math/rev/functor/integrate_ode_bdf.hpp
@@ -13,10 +13,10 @@ namespace math {
 /**
  *  @deprecated use <code>ode_bdf</code>
  */
-template <typename F, typename T_initial, typename T_param, typename T_t0,
+template <typename F, typename T_y0, typename T_param, typename T_t0,
           typename T_ts>
-std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>>
-integrate_ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
+std::vector<std::vector<return_type_t<T_y0, T_param, T_t0, T_ts>>>
+integrate_ode_bdf(const F& f, const std::vector<T_y0>& y0, const T_t0& t0,
                   const std::vector<T_ts>& ts,
                   const std::vector<T_param>& theta,
                   const std::vector<double>& x, const std::vector<int>& x_int,
@@ -29,7 +29,7 @@ integrate_ode_bdf(const F& f, const std::vector<T_initial>& y0, const T_t0& t0,
                             ts, relative_tolerance, absolute_tolerance,
                             max_num_steps, msgs, theta, x, x_int);
 
-  std::vector<std::vector<return_type_t<T_initial, T_param, T_t0, T_ts>>>
+  std::vector<std::vector<return_type_t<T_y0, T_param, T_t0, T_ts>>>
       y_converted;
   for (size_t i = 0; i < y.size(); ++i)
     y_converted.push_back(to_array_1d(y[i]));
diff --git a/stan/math/rev/functor/ode_adams.hpp b/stan/math/rev/functor/ode_adams.hpp
index 87f56ce5ece..7fc7194a5b1 100644
--- a/stan/math/rev/functor/ode_adams.hpp
+++ b/stan/math/rev/functor/ode_adams.hpp
@@ -42,17 +42,17 @@ namespace math {
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return Solution to ODE at times \p ts
  */
-template <typename F, typename T_initial, typename T_t0, typename T_ts,
+template <typename F, typename T_y0, typename T_t0, typename T_ts,
           typename... T_Args>
-std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
+std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
 ode_adams_tol_impl(const char* function_name, const F& f,
-                   const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+                   const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
                    const T_t0& t0, const std::vector<T_ts>& ts,
                    double relative_tolerance, double absolute_tolerance,
                    long int max_num_steps,  // NOLINT(runtime/int)
                    std::ostream* msgs, const T_Args&... args) {
-  cvodes_integrator<CV_ADAMS, F, T_initial, T_t0, T_ts, T_Args...> integrator(
+  cvodes_integrator<CV_ADAMS, F, T_y0, T_t0, T_ts, T_Args...> integrator(
       function_name, f, y0, t0, ts, relative_tolerance, absolute_tolerance,
       max_num_steps, msgs, args...);
 
@@ -92,11 +92,11 @@ ode_adams_tol_impl(const char* function_name, const F& f,
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return Solution to ODE at times \p ts
  */
-template <typename F, typename T_initial, typename T_t0, typename T_ts,
+template <typename F, typename T_y0, typename T_t0, typename T_ts,
           typename... T_Args>
-std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
+std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
-ode_adams_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+ode_adams_tol(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
               const T_t0& t0, const std::vector<T_ts>& ts,
               double relative_tolerance, double absolute_tolerance,
               long int max_num_steps,  // NOLINT(runtime/int)
@@ -135,11 +135,11 @@ ode_adams_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return Solution to ODE at times \p ts
  */
-template <typename F, typename T_initial, typename T_t0, typename T_ts,
+template <typename F, typename T_y0, typename T_t0, typename T_ts,
           typename... T_Args>
-std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
+std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
-ode_adams(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+ode_adams(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
           const T_t0& t0, const std::vector<T_ts>& ts, std::ostream* msgs,
           const T_Args&... args) {
   double relative_tolerance = 1e-10;
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index ad7a3f5ea91..95de692719c 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -42,17 +42,17 @@ namespace math {
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return Solution to ODE at times \p ts
  */
-template <typename F, typename T_initial, typename T_t0, typename T_ts,
+template <typename F, typename T_y0, typename T_t0, typename T_ts,
           typename... T_Args>
-std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
+std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
 ode_bdf_tol_impl(const char* function_name, const F& f,
-                 const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+                 const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
                  const T_t0& t0, const std::vector<T_ts>& ts,
                  double relative_tolerance, double absolute_tolerance,
                  long int max_num_steps,  // NOLINT(runtime/int)
                  std::ostream* msgs, const T_Args&... args) {
-  cvodes_integrator<CV_BDF, F, T_initial, T_t0, T_ts, T_Args...> integrator(
+  cvodes_integrator<CV_BDF, F, T_y0, T_t0, T_ts, T_Args...> integrator(
       function_name, f, y0, t0, ts, relative_tolerance, absolute_tolerance,
       max_num_steps, msgs, args...);
 
@@ -92,11 +92,11 @@ ode_bdf_tol_impl(const char* function_name, const F& f,
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return Solution to ODE at times \p ts
  */
-template <typename F, typename T_initial, typename T_t0, typename T_ts,
+template <typename F, typename T_y0, typename T_t0, typename T_ts,
           typename... T_Args>
-std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
+std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
-ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+ode_bdf_tol(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
             const T_t0& t0, const std::vector<T_ts>& ts,
             double relative_tolerance, double absolute_tolerance,
             long int max_num_steps,  // NOLINT(runtime/int)
@@ -135,11 +135,11 @@ ode_bdf_tol(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
  * @param args Extra arguments passed unmodified through to ODE right hand side
  * @return Solution to ODE at times \p ts
  */
-template <typename F, typename T_initial, typename T_t0, typename T_ts,
+template <typename F, typename T_y0, typename T_t0, typename T_ts,
           typename... T_Args>
-std::vector<Eigen::Matrix<stan::return_type_t<T_initial, T_t0, T_ts, T_Args...>,
+std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, T_Args...>,
                           Eigen::Dynamic, 1>>
-ode_bdf(const F& f, const Eigen::Matrix<T_initial, Eigen::Dynamic, 1>& y0,
+ode_bdf(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
         const T_t0& t0, const std::vector<T_ts>& ts, std::ostream* msgs,
         const T_Args&... args) {
   double relative_tolerance = 1e-10;
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index e7cbdcb9215..152c3e8d9af 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -14,11 +14,9 @@ namespace math {
  * Build output vars for a state of the ODE solve, storing the sensitivities
  * precomputed using the forward sensitivity problem in precomputed varis.
  *
- * Any combination of y0, t0, ts, and any of the args arguments can have the
- * var scalar type.
- *
  * @tparam F Type of ODE right hand side
- * @tparam T_0 Type of initial time
+ * @tparam T_y0_t0 Type of initial state
+ * @tparam T_t0 Type of initial time
  * @tparam T_ts Type of output times
  * @tparam T_Args Types of pass-through parameters
  *
@@ -82,7 +80,7 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
       partials_j[y0_vars + k] = coupled_state[N + N * y0_vars + N * k + j];
     }
 
-    if (t0_vars > 0) {
+    if (is_var<T_t0>::value) {
       double dyt_dt0 = 0.0;
       for (size_t k = 0; k < y0_vars; ++k) {
         dyt_dt0 += -f_y0_t0.coeffRef(k) * coupled_state[N + y0_vars * k + j];
@@ -90,7 +88,7 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
       partials_j[y0_vars + args_vars] = dyt_dt0;
     }
 
-    if (t_vars > 0) {
+    if (is_var<T_t>::value) {
       partials_j[y0_vars + args_vars + t0_vars] = f_y_t.coeffRef(j);
     }
 

From cbdace59a281595c44367c32d9e0693ea6d85e8b Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Wed, 1 Jul 2020 02:26:01 +0000
Subject: [PATCH 149/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

---
 stan/math/prim/functor/coupled_ode_system.hpp |  8 +++----
 stan/math/prim/functor/integrate_ode_rk45.hpp |  3 ++-
 stan/math/prim/functor/ode_rk45.hpp           | 22 +++++++++----------
 stan/math/rev/functor/coupled_ode_system.hpp  |  6 ++---
 stan/math/rev/functor/cvodes_integrator.hpp   |  4 ++--
 stan/math/rev/functor/integrate_ode_adams.hpp |  4 ++--
 .../math/prim/functor/ode_rk45_prim_test.cpp  |  3 +--
 .../prim/functor/ode_rk45_tol_prim_test.cpp   |  2 +-
 .../math/rev/functor/ode_bdf_prim_test.cpp    |  3 +--
 9 files changed, 26 insertions(+), 29 deletions(-)

diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
index c154726b07e..2c8a0e1fd70 100644
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -102,14 +102,14 @@ struct coupled_ode_system_impl<true, F, T_y0, Args...> {
 template <typename F, typename T_y0, typename... Args>
 struct coupled_ode_system
     : public coupled_ode_system_impl<
-          std::is_arithmetic<return_type_t<T_y0, Args...>>::value, F,
-          T_y0, Args...> {
+          std::is_arithmetic<return_type_t<T_y0, Args...>>::value, F, T_y0,
+          Args...> {
   coupled_ode_system(const F& f,
                      const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
                      std::ostream* msgs, const Args&... args)
       : coupled_ode_system_impl<
-            std::is_arithmetic<return_type_t<T_y0, Args...>>::value, F,
-            T_y0, Args...>(f, y0, msgs, args...) {}
+            std::is_arithmetic<return_type_t<T_y0, Args...>>::value, F, T_y0,
+            Args...>(f, y0, msgs, args...) {}
 };
 
 }  // namespace math
diff --git a/stan/math/prim/functor/integrate_ode_rk45.hpp b/stan/math/prim/functor/integrate_ode_rk45.hpp
index 50686b2396c..214441edd55 100644
--- a/stan/math/prim/functor/integrate_ode_rk45.hpp
+++ b/stan/math/prim/functor/integrate_ode_rk45.hpp
@@ -28,7 +28,8 @@ integrate_ode_rk45(const F& f, const std::vector<T_y0>& y0, const T_t0& t0,
                              ts, relative_tolerance, absolute_tolerance,
                              max_num_steps, msgs, theta, x, x_int);
 
-  std::vector<std::vector<return_type_t<T_y0, T_param, T_t0, T_ts>>> y_converted;
+  std::vector<std::vector<return_type_t<T_y0, T_param, T_t0, T_ts>>>
+      y_converted;
   for (size_t i = 0; i < y.size(); ++i)
     y_converted.push_back(to_array_1d(y[i]));
 
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index 9126c33f4ee..f1400aa3302 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -55,9 +55,9 @@ template <typename F, typename T_y0, typename T_t0, typename T_ts,
 std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, Args...>,
                           Eigen::Dynamic, 1>>
 ode_rk45_tol_impl(const char* function_name, const F& f,
-                  const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0_arg,
-                  T_t0 t0, const std::vector<T_ts>& ts,
-                  double relative_tolerance, double absolute_tolerance,
+                  const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0_arg, T_t0 t0,
+                  const std::vector<T_ts>& ts, double relative_tolerance,
+                  double absolute_tolerance,
                   long int max_num_steps,  // NOLINT(runtime/int)
                   std::ostream* msgs, const Args&... args) {
   using boost::numeric::odeint::integrate_times;
@@ -68,7 +68,8 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
 
   using T_y0_t0 = return_type_t<T_y0, T_t0>;
 
-  Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1> y0 = y0_arg.template cast<T_y0_t0>();
+  Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1> y0
+      = y0_arg.template cast<T_y0_t0>();
 
   check_finite(function_name, "initial state", y0);
   check_finite(function_name, "initial time", t0);
@@ -91,8 +92,7 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
 
   using return_t = return_type_t<T_y0, T_t0, T_ts, Args...>;
   // creates basic or coupled system by template specializations
-  coupled_ode_system<F, T_y0_t0, Args...> coupled_system(f, y0, msgs,
-                                                                 args...);
+  coupled_ode_system<F, T_y0_t0, Args...> coupled_system(f, y0, msgs, args...);
 
   // first time in the vector must be time of initial state
   std::vector<double> ts_vec(ts.size() + 1);
@@ -174,9 +174,8 @@ template <typename F, typename T_y0, typename T_t0, typename T_ts,
           typename... Args>
 std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, Args...>,
                           Eigen::Dynamic, 1>>
-ode_rk45_tol(const F& f,
-             const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0_arg, T_t0 t0,
-             const std::vector<T_ts>& ts, double relative_tolerance,
+ode_rk45_tol(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0_arg,
+             T_t0 t0, const std::vector<T_ts>& ts, double relative_tolerance,
              double absolute_tolerance,
              long int max_num_steps,  // NOLINT(runtime/int)
              std::ostream* msgs, const Args&... args) {
@@ -222,9 +221,8 @@ template <typename F, typename T_y0, typename T_t0, typename T_ts,
           typename... Args>
 std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, Args...>,
                           Eigen::Dynamic, 1>>
-ode_rk45(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
-         T_t0 t0, const std::vector<T_ts>& ts, std::ostream* msgs,
-         const Args&... args) {
+ode_rk45(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0, T_t0 t0,
+         const std::vector<T_ts>& ts, std::ostream* msgs, const Args&... args) {
   double relative_tolerance = 1e-6;
   double absolute_tolerance = 1e-6;
   long int max_num_steps = 1e6;  // NOLINT(runtime/int)
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index 1b09de8ef2f..2141061ab68 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -174,11 +174,11 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
           local_args_tuple_);
 
       apply([&](auto&&... args) { zero_local_adjoints(args...); },
-	    local_args_tuple_);
+            local_args_tuple_);
 
       // No need to zero adjoints after last sweep
-      if(i < N_) {
-	nested.set_zero_all_adjoints();
+      if (i < N_) {
+        nested.set_zero_all_adjoints();
       }
 
       for (size_t j = 0; j < y0_vars_; ++j) {
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 10930b13b30..e8dfd18f699 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -296,8 +296,8 @@ class cvodes_integrator {
         check_flag_sundials(CVodeSetSensErrCon(cvodes_mem, SUNTRUE),
                             "CVodeSetSensErrCon");
 
-	check_flag_sundials(CVodeSensEEtolerances(cvodes_mem),
-			    "CVodeSensEEtolerances");
+        check_flag_sundials(CVodeSensEEtolerances(cvodes_mem),
+                            "CVodeSensEEtolerances");
       }
 
       double t_init = value_of(t0_);
diff --git a/stan/math/rev/functor/integrate_ode_adams.hpp b/stan/math/rev/functor/integrate_ode_adams.hpp
index 77421c006a7..0cba70a321e 100644
--- a/stan/math/rev/functor/integrate_ode_adams.hpp
+++ b/stan/math/rev/functor/integrate_ode_adams.hpp
@@ -16,8 +16,8 @@ namespace math {
 template <typename F, typename T_y0, typename T_param, typename T_t0,
           typename T_ts>
 std::vector<std::vector<return_type_t<T_y0, T_param, T_t0, T_ts>>>
-integrate_ode_adams(const F& f, const std::vector<T_y0>& y0,
-                    const T_t0& t0, const std::vector<T_ts>& ts,
+integrate_ode_adams(const F& f, const std::vector<T_y0>& y0, const T_t0& t0,
+                    const std::vector<T_ts>& ts,
                     const std::vector<T_param>& theta,
                     const std::vector<double>& x, const std::vector<int>& x_int,
                     std::ostream* msgs = nullptr,
diff --git a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
index c23ae5e96e0..4491f7194a5 100644
--- a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
@@ -121,8 +121,7 @@ TEST(ode_rk45_prim, ts_errors) {
   EXPECT_NO_THROW(
       stan::math::ode_rk45(CosArg1(), y0, t0, ts_repeat, nullptr, a));
 
-  EXPECT_NO_THROW(
-      stan::math::ode_rk45(CosArg1(), y0, t0, ts_lots, nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts_lots, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts_empty, nullptr, a),
                std::invalid_argument);
diff --git a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
index cb156121467..b3409bd343e 100644
--- a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
@@ -129,7 +129,7 @@ TEST(ode_rk45_tol_prim, ts_errors) {
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
                                            1e-10, 1e6, nullptr, a));
 
-    EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
                                            1e-10, 1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index 8f39d5e4843..852fd281b14 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -121,8 +121,7 @@ TEST(ode_bdf_prim, ts_errors) {
   EXPECT_NO_THROW(
       stan::math::ode_bdf(CosArg1(), y0, t0, ts_repeat, nullptr, a));
 
-  EXPECT_NO_THROW(
-      stan::math::ode_bdf(CosArg1(), y0, t0, ts_lots, nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts_lots, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts_empty, nullptr, a),
                std::invalid_argument);

From 9f923e8fec8cf2c2343a96279ed2de274f5b40fb Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Wed, 1 Jul 2020 20:38:17 -0400
Subject: [PATCH 150/189] Added support for general arguments to variadic ODEs
 (design-doc #19)

---
 stan/math/prim/err/check_finite.hpp           | 112 ++--
 stan/math/prim/fun/value_of.hpp               | 131 ++---
 stan/math/prim/functor/coupled_ode_system.hpp |   6 +-
 stan/math/rev/functor/coupled_ode_system.hpp  |  24 +-
 stan/math/rev/functor/cvodes_integrator.hpp   |   2 +-
 test/unit/math/prim/fun/value_of_test.cpp     |  11 +
 .../math/prim/functor/ode_rk45_prim_test.cpp  |  50 +-
 .../prim/functor/ode_rk45_tol_prim_test.cpp   |  60 +++
 test/unit/math/rev/fun/value_of_test.cpp      |   1 +
 .../math/rev/functor/ode_adams_prim_test.cpp  |  48 ++
 .../math/rev/functor/ode_adams_rev_test.cpp   | 177 ++++--
 .../rev/functor/ode_adams_tol_prim_test.cpp   | 158 ++++--
 .../rev/functor/ode_adams_tol_rev_test.cpp    | 510 +++++-------------
 .../math/rev/functor/ode_bdf_prim_test.cpp    |  48 ++
 .../math/rev/functor/ode_bdf_rev_test.cpp     | 177 ++++--
 .../rev/functor/ode_bdf_tol_prim_test.cpp     | 180 ++++---
 .../math/rev/functor/ode_bdf_tol_rev_test.cpp | 498 ++++-------------
 .../math/rev/functor/ode_rk45_rev_test.cpp    | 177 ++++--
 .../rev/functor/ode_rk45_tol_rev_test.cpp     |  87 +++
 19 files changed, 1283 insertions(+), 1174 deletions(-)

diff --git a/stan/math/prim/err/check_finite.hpp b/stan/math/prim/err/check_finite.hpp
index eb59930b3c5..72093db9fc5 100644
--- a/stan/math/prim/err/check_finite.hpp
+++ b/stan/math/prim/err/check_finite.hpp
@@ -14,29 +14,30 @@
 
 namespace stan {
 namespace math {
-
 namespace internal {
-template <typename T_y, bool is_vec>
-struct finite {
-  static void check(const char* function, const char* name, const T_y& y) {
-    if (!is_scal_finite(y)) {
-      throw_domain_error(function, name, y, "is ", ", but must be finite!");
-    }
+template <typename T_y>
+bool is_finite(const T_y& y) {
+  return is_scal_finite(y);
+}
+
+template <typename T_y, int R, int C>
+bool is_finite(const Eigen::Matrix<T_y, R, C>& y) {
+  bool all = true;
+  for (size_t n = 0; n < y.size(); ++n) {
+    all &= is_finite(y(n));
   }
-};
+  return all;
+}
 
 template <typename T_y>
-struct finite<T_y, true> {
-  static void check(const char* function, const char* name, const T_y& y) {
-    for (size_t n = 0; n < stan::math::size(y); n++) {
-      if (!is_scal_finite(stan::get(y, n))) {
-        throw_domain_error_vec(function, name, y, n, "is ",
-                               ", but must be finite!");
-      }
-    }
+bool is_finite(const std::vector<T_y>& y) {
+  bool all = true;
+  for (size_t n = 0; n < stan::math::size(y); ++n) {
+    all &= is_finite(y[n]);
   }
-};
-}  // namespace internal
+  return all;
+}
+}
 
 /**
  * Check if <code>y</code> is finite.
@@ -48,15 +49,40 @@ struct finite<T_y, true> {
  * @param y Variable to check
  * @throw <code>domain_error</code> if y is infinity, -infinity, or NaN
  */
-template <typename T_y>
+template <typename T_y,
+	  require_stan_scalar_t<T_y>* = nullptr>
 inline void check_finite(const char* function, const char* name, const T_y& y) {
-  internal::finite<T_y, is_vector_like<T_y>::value>::check(function, name, y);
+  if (!internal::is_finite(y)) {
+    throw_domain_error(function, name, y, "is ", ", but must be finite!");
+  }
+}
+
+/**
+ * Return <code>true</code> if all values in the std::vector are finite.
+ *
+ * @tparam T_y type of elements in the std::vector
+ *
+ * @param function name of function (for error messages)
+ * @param name variable name (for error messages)
+ * @param y std::vector to test
+ * @return <code>true</code> if all values are finite
+ **/
+template <typename T_y,
+	  require_stan_scalar_t<T_y>* = nullptr>
+inline void check_finite(const char* function, const char* name,
+			 const std::vector<T_y>& y) {
+  for (size_t n = 0; n < stan::math::size(y); n++) {
+    if (!internal::is_finite(stan::get(y, n))) {
+      throw_domain_error_vec(function, name, y, n, "is ",
+			     ", but must be finite!");
+    }
+  }
 }
 
 /**
  * Return <code>true</code> is the specified matrix is finite.
  *
- * @tparam T type of elements in the matrix
+ * @tparam T_y type of elements in the matrix
  * @tparam R number of rows, can be Eigen::Dynamic
  * @tparam C number of columns, can be Eigen::Dynamic
  *
@@ -65,23 +91,41 @@ inline void check_finite(const char* function, const char* name, const T_y& y) {
  * @param y matrix to test
  * @return <code>true</code> if the matrix is finite
  **/
-namespace internal {
-template <typename T, int R, int C>
-struct finite<Eigen::Matrix<T, R, C>, true> {
-  static void check(const char* function, const char* name,
-                    const Eigen::Matrix<T, R, C>& y) {
-    if (!value_of(y).allFinite()) {
-      for (int n = 0; n < y.size(); ++n) {
-        if (!std::isfinite(value_of_rec(y(n)))) {
-          throw_domain_error_vec(function, name, y, n, "is ",
-                                 ", but must be finite!");
-        }
+template <typename T_y, int R, int C>
+inline void check_finite(const char* function, const char* name,
+			 const Eigen::Matrix<T_y, R, C>& y) {
+  if (!value_of(y).allFinite()) {
+    for (int n = 0; n < y.size(); ++n) {
+      if (!std::isfinite(value_of_rec(y(n)))) {
+	throw_domain_error_vec(function, name, y, n, "is ",
+			       ", but must be finite!");
       }
     }
   }
-};
+}
+
+/**
+ * Return <code>true</code> if all values in the std::vector are finite.
+ *
+ * @tparam T_y type of elements in the std::vector
+ *
+ * @param function name of function (for error messages)
+ * @param name variable name (for error messages)
+ * @param y std::vector to test
+ * @return <code>true</code> if all values are finite
+ **/
+template <typename T_y,
+	  require_not_stan_scalar_t<T_y>* = nullptr>
+inline void check_finite(const char* function, const char* name,
+			 const std::vector<T_y>& y) {
+  for (size_t n = 0; n < stan::math::size(y); n++) {
+    if (!internal::is_finite(stan::get(y, n))) {
+      throw_domain_error(function, name, "", "",
+			 "is not finite!");
+    }
+  }
+}
 
-}  // namespace internal
 }  // namespace math
 }  // namespace stan
 
diff --git a/stan/math/prim/fun/value_of.hpp b/stan/math/prim/fun/value_of.hpp
index 6354a13d340..cb8acecd56b 100644
--- a/stan/math/prim/fun/value_of.hpp
+++ b/stan/math/prim/fun/value_of.hpp
@@ -10,127 +10,56 @@ namespace stan {
 namespace math {
 
 /**
- * Return the value of the specified scalar argument
- * converted to a double value.
+ * Inputs that are arithmetic types or containers of airthmetric types
+ * are returned from value_of unchanged
  *
- * <p>See the <code>primitive_value</code> function to
- * extract values without casting to <code>double</code>.
- *
- * <p>This function is meant to cover the primitive types. For
- * types requiring pass-by-reference, this template function
- * should be specialized.
- *
- * @tparam T type of scalar.
- * @param x scalar to convert to double
- * @return value of scalar cast to double
- */
-template <typename T, require_arithmetic_t<T>* = nullptr>
-inline double value_of(const T x) {
-  return static_cast<double>(x);
-}
-
-/**
- * Return the specified argument.
- *
- * <p>See <code>value_of(T)</code> for a polymorphic
- * implementation using static casts.
- *
- * <p>This inline pass-through no-op should be compiled away.
- *
- * @param x value
- * @return input value
- */
-template <>
-inline double value_of<double>(double x) {
-  return x;
+ * @tparam T Input type
+ * @param[in] x Input argument
+ * @return Forwarded input argument
+ **/
+template <typename T,
+	  require_arithmetic_t<stan::return_type_t<T>>* = nullptr>
+inline decltype(auto) value_of(T&& x) {
+  return std::forward<decltype(x)>(x);
 }
 
 /**
- * Return the specified argument.
- *
- * <p>See <code>value_of(T)</code> for a polymorphic
- * implementation using static casts.
- *
- * <p>This inline pass-through no-op should be compiled away.
- *
- * @param x value
- * @return input value
- */
-inline int value_of(int x) { return x; }
-
-/**
- * Convert a std::vector of type T to a std::vector of
- * child_type<T>::type.
+ * For std::vectors of non-arithmetic types, return a std::vector composed
+ * of value_of applied to each element.
  *
- * @tparam T Scalar type in std::vector
- * @param[in] x std::vector to be converted
+ * @tparam T Input element type
+ * @param[in] x Input std::vector
  * @return std::vector of values
  **/
-template <typename T, require_not_double_or_int_t<T>* = nullptr>
-inline std::vector<typename child_type<T>::type> value_of(
-    const std::vector<T>& x) {
-  size_t x_size = x.size();
-  std::vector<typename child_type<T>::type> result(x_size);
-  for (size_t i = 0; i < x_size; i++) {
-    result[i] = value_of(x[i]);
-  }
-  return result;
+template <typename T,
+	  require_not_arithmetic_t<stan::return_type_t<T>>* = nullptr>
+inline auto value_of(const std::vector<T>& x) {
+  std::vector<std::decay_t<decltype(value_of(std::declval<T>()))>> out;
+  out.reserve(x.size());
+  for (size_t n = 0; n < x.size(); ++n)
+    out.emplace_back(value_of(x[n]));
+  return out;
 }
 
 /**
- * Return the specified argument.
- *
- * <p>See <code>value_of(T)</code> for a polymorphic
- * implementation using static casts.
- *
- * <p>This inline pass-through no-op should be compiled away.
- *
- * @param x Specified std::vector.
- * @return Specified std::vector.
- */
-template <typename Vec, require_std_vector_vt<is_double_or_int, Vec>* = nullptr>
-inline Vec value_of(Vec&& x) {
-  return std::forward<Vec>(x);
-}
-
-/**
- * Convert a matrix of type T to a matrix of doubles.
- *
- * T must implement value_of. See
- * test/math/fwd/fun/value_of.cpp for fvar and var usage.
+ * For Eigen matrices and expressions of non-arithmetic types, return an expression
+ * that represents the Eigen::Matrix resulting from applying value_of elementwise
  *
  * @tparam EigMat type of the matrix
  *
  * @param[in] M Matrix to be converted
  * @return Matrix of values
  **/
-template <typename EigMat, require_eigen_t<EigMat>* = nullptr,
-          require_not_vt_double_or_int<EigMat>* = nullptr>
+template <typename EigMat,
+	  require_eigen_t<EigMat>* = nullptr,
+	  require_not_arithmetic_t<stan::return_type_t<EigMat>>* = nullptr>
 inline auto value_of(EigMat&& M) {
-  return make_holder(
+  /*return make_holder(
       [](auto& a) {
         return a.unaryExpr([](const auto& scal) { return value_of(scal); });
       },
-      std::forward<EigMat>(M));
-}
-
-/**
- * Return the specified argument.
- *
- * <p>See <code>value_of(T)</code> for a polymorphic
- * implementation using static casts.
- *
- * <p>This inline pass-through no-op should be compiled away.
- *
- * @tparam EigMat type of the matrix
- *
- * @param x Specified matrix.
- * @return Specified matrix.
- */
-template <typename EigMat,
-          require_eigen_vt<is_double_or_int, EigMat>* = nullptr>
-inline EigMat value_of(EigMat&& x) {
-  return std::forward<EigMat>(x);
+      std::forward<EigMat>(M));*/
+  return M.unaryExpr([](const auto& scal) { return value_of(scal); }).eval();
 }
 
 }  // namespace math
diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
index c154726b07e..5a6fd2ac3a7 100644
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -63,16 +63,16 @@ struct coupled_ode_system_impl<true, F, T_y0, Args...> {
     for (size_t n = 0; n < N_; ++n)
       y.coeffRef(n) = z[n];
 
-    dy_dt.resize(N_);
+    dz_dt.resize(N_);
 
     Eigen::VectorXd f_y_t
         = apply([&](const Args&... args) { return f_(t, y, msgs_, args...); },
                 args_tuple_);
 
-    check_size_match("coupled_ode_system", "y", y.size(), "dy_dt",
+    check_size_match("coupled_ode_system", "y", y.size(), "dz_dt",
                      f_y_t.size());
 
-    Eigen::Map<Eigen::VectorXd>(dy_dt.data(), dy_dt.size()) = f_y_t;
+    Eigen::Map<Eigen::VectorXd>(dz_dt.data(), dz_dt.size()) = f_y_t;
   }
 
   /**
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index 1b09de8ef2f..2ebdf795120 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -99,31 +99,31 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
         y_adjoints_(N_),
         msgs_(msgs) {}
 
-  inline void zero_local_adjoints() {}
+  inline void zero_adjoints() {}
 
   template <typename T, typename... Pargs>
-  inline void zero_local_adjoints(T& x, Pargs&... args) {
-    zero_local_adjoints(args...);
+  inline void zero_adjoints(T& x, Pargs&... args) {
+    zero_adjoints(args...);
   }
 
   template <typename... Pargs>
-  inline void zero_local_adjoints(var& x, Pargs&... args) {
+  inline void zero_adjoints(var& x, Pargs&... args) {
     x.vi_->set_zero_adjoint();
-    zero_local_adjoints(args...);
+    zero_adjoints(args...);
   }
 
-  template <typename... Pargs>
-  inline void zero_local_adjoints(std::vector<var>& x, Pargs&... args) {
+  template <typename T, typename... Pargs>
+  inline void zero_adjoints(std::vector<T>& x, Pargs&... args) {
     for (size_t i = 0; i < x.size(); ++i)
-      x[i].vi_->set_zero_adjoint();
-    zero_local_adjoints(args...);
+      zero_adjoints(x[i]);
+    zero_adjoints(args...);
   }
 
   template <int R, int C, typename... Pargs>
-  inline void zero_local_adjoints(Eigen::Matrix<var, R, C>& x, Pargs&... args) {
+  inline void zero_adjoints(Eigen::Matrix<var, R, C>& x, Pargs&... args) {
     for (size_t i = 0; i < x.size(); ++i)
       x.coeffRef(i).vi_->set_zero_adjoint();
-    zero_local_adjoints(args...);
+    zero_adjoints(args...);
   }
 
   /**
@@ -173,7 +173,7 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
           },
           local_args_tuple_);
 
-      apply([&](auto&&... args) { zero_local_adjoints(args...); },
+      apply([&](auto&&... args) { zero_adjoints(args...); },
 	    local_args_tuple_);
 
       // No need to zero adjoints after last sweep
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 10930b13b30..a3a60505fcf 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -40,7 +40,7 @@ class cvodes_integrator {
   const T_t0 t0_;
   const std::vector<T_ts>& ts_;
   std::tuple<const T_Args&...> args_tuple_;
-  std::tuple<plain_type_t<decltype(value_of(T_Args()))>...>
+  std::tuple<plain_type_t<decltype(value_of(std::declval<T_Args>()))>...>
       value_of_args_tuple_;
   const size_t N_;
   std::ostream* msgs_;
diff --git a/test/unit/math/prim/fun/value_of_test.cpp b/test/unit/math/prim/fun/value_of_test.cpp
index a9881261d4a..ea90da3fdda 100644
--- a/test/unit/math/prim/fun/value_of_test.cpp
+++ b/test/unit/math/prim/fun/value_of_test.cpp
@@ -75,6 +75,17 @@ TEST(MathMatrixPrimMat, value_of) {
   EXPECT_MATRIX_FLOAT_EQ(b, d_b);
 }
 
+TEST(MathFunctions, value_of_vector_of_vectors) {
+  std::vector<double> a(5, 0);
+  const std::vector<double> b(5, 0);
+  std::vector<std::vector<double>> va(5, a);
+  const std::vector<std::vector<double>> vb(5, b);
+  EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(va)),
+	       std::vector<std::vector<double>>&>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(vb)),
+	       const std::vector<std::vector<double>>&>::value));
+}
+
 TEST(MathMatrixPrimMat, value_of_expression) {
   using stan::math::value_of;
 
diff --git a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
index c23ae5e96e0..d3992094fdd 100644
--- a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
@@ -1,4 +1,4 @@
-#include <stan/math/rev.hpp>
+#include <stan/math/prim.hpp>
 #include <gtest/gtest.h>
 #include <test/unit/util.hpp>
 #include <iostream>
@@ -161,6 +161,14 @@ TEST(ode_rk45_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
+  std::vector<std::vector<double>> vva = { va };
+  std::vector<std::vector<double>> vvainf = { vainf };
+  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+
+  std::vector<Eigen::VectorXd> vea = { ea };
+  std::vector<Eigen::VectorXd> veainf = { eainf };
+  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+
   EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, ainf),
@@ -184,6 +192,22 @@ TEST(ode_rk45_prim, one_arg_errors) {
 
   EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, eaNaN),
                std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, vva));
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, vvainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, vvaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, vea));
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, veainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, veaNaN),
+               std::domain_error);
 }
 
 TEST(ode_rk45_prim, two_arg_errors) {
@@ -206,6 +230,14 @@ TEST(ode_rk45_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
+  std::vector<std::vector<double>> vva = { va };
+  std::vector<std::vector<double>> vvainf = { vainf };
+  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+
+  std::vector<Eigen::VectorXd> vea = { ea };
+  std::vector<Eigen::VectorXd> veainf = { eainf };
+  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+
   EXPECT_NO_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, a));
 
   EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, ainf),
@@ -229,6 +261,22 @@ TEST(ode_rk45_prim, two_arg_errors) {
 
   EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, eaNaN),
                std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, vva));
+
+  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, vvainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, vvaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, vea));
+
+  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, veainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, veaNaN),
+               std::domain_error);
 }
 
 TEST(ode_rk45_prim, rhs_wrong_size_errors) {
diff --git a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
index cb156121467..f2b23e557cc 100644
--- a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
@@ -173,6 +173,14 @@ TEST(ode_rk45_tol_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
+  std::vector<std::vector<double>> vva = { va };
+  std::vector<std::vector<double>> vvainf = { vainf };
+  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+
+  std::vector<Eigen::VectorXd> vea = { ea };
+  std::vector<Eigen::VectorXd> veainf = { eainf };
+  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
                                            1e6, nullptr, a));
 
@@ -205,6 +213,28 @@ TEST(ode_rk45_tol_prim, one_arg_errors) {
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
                                         1e6, nullptr, eaNaN),
                std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, vva));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, vvainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, vvaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, vea));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, veainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, veaNaN),
+               std::domain_error);
 }
 
 TEST(ode_rk45_tol_prim, two_arg_errors) {
@@ -227,6 +257,14 @@ TEST(ode_rk45_tol_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
+  std::vector<std::vector<double>> vva = { va };
+  std::vector<std::vector<double>> vvainf = { vainf };
+  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+
+  std::vector<Eigen::VectorXd> vea = { ea };
+  std::vector<Eigen::VectorXd> veainf = { eainf };
+  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
                                            1e6, nullptr, a, a));
 
@@ -259,6 +297,28 @@ TEST(ode_rk45_tol_prim, two_arg_errors) {
   EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
                                         1e6, nullptr, a, eaNaN),
                std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, a, vva));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, vvainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, vvaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, a, vea));
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, veainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, veaNaN),
+               std::domain_error);
 }
 
 TEST(ode_rk45_tol_prim, rtol_errors) {
diff --git a/test/unit/math/rev/fun/value_of_test.cpp b/test/unit/math/rev/fun/value_of_test.cpp
index 2f1f51951ae..26da36278c6 100644
--- a/test/unit/math/rev/fun/value_of_test.cpp
+++ b/test/unit/math/rev/fun/value_of_test.cpp
@@ -115,3 +115,4 @@ TEST(AgradMatrixRev, value_of_matrix_rvalue) {
 
   EXPECT_MATRIX_NEAR(res, correct, 1e-10);
 }
+
diff --git a/test/unit/math/rev/functor/ode_adams_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
index 754e558fd34..84cc4dad8cb 100644
--- a/test/unit/math/rev/functor/ode_adams_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
@@ -161,6 +161,14 @@ TEST(ode_adams_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
+  std::vector<std::vector<double>> vva = { va };
+  std::vector<std::vector<double>> vvainf = { vainf };
+  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+
+  std::vector<Eigen::VectorXd> vea = { ea };
+  std::vector<Eigen::VectorXd> veainf = { eainf };
+  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+
   EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, ainf),
@@ -184,6 +192,22 @@ TEST(ode_adams_prim, one_arg_errors) {
 
   EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, eaNaN),
                std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, vva));
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, vvainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, vvaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, vea));
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, veainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, veaNaN),
+               std::domain_error);
 }
 
 TEST(ode_adams_prim, two_arg_errors) {
@@ -206,6 +230,14 @@ TEST(ode_adams_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
+  std::vector<std::vector<double>> vva = { va };
+  std::vector<std::vector<double>> vvainf = { vainf };
+  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+
+  std::vector<Eigen::VectorXd> vea = { ea };
+  std::vector<Eigen::VectorXd> veainf = { eainf };
+  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+
   EXPECT_NO_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, a));
 
   EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, ainf),
@@ -229,6 +261,22 @@ TEST(ode_adams_prim, two_arg_errors) {
 
   EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, eaNaN),
                std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, vva));
+
+  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, vvainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, vvaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, vea));
+
+  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, veainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, veaNaN),
+               std::domain_error);
 }
 
 TEST(ode_adams_prim, rhs_wrong_size_errors) {
diff --git a/test/unit/math/rev/functor/ode_adams_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
index b164aeb1427..4a19cd01bdb 100644
--- a/test/unit/math/rev/functor/ode_adams_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
@@ -61,8 +61,8 @@ TEST(StanMathOde_ode_adams, int_t0) {
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a);
 
-  EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
-  EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
+  EXPECT_NEAR(output[0][0], 0.4165982112, 1e-5);
+  EXPECT_NEAR(output[1][0], 0.66457668563, 1e-5);
 }
 
 TEST(StanMathOde_ode_adams, int_ts) {
@@ -77,8 +77,8 @@ TEST(StanMathOde_ode_adams, int_ts) {
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a);
 
-  EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
-  EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
+  EXPECT_NEAR(output[0][0], 0.6649966577, 1e-5);
+  EXPECT_NEAR(output[1][0], 0.09408000537, 1e-5);
 }
 
 TEST(StanMathOde_ode_adams, t0) {
@@ -95,15 +95,15 @@ TEST(StanMathOde_ode_adams, t0) {
 
   output[0][0].grad();
 
-  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+  EXPECT_NEAR(output[0][0].val(), 0.4165982112, 1e-5);
+  EXPECT_NEAR(t0.adj(), -1.0, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[1][0].grad();
 
-  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+  EXPECT_NEAR(output[1][0].val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(t0.adj(), -1.0, 1e-5);
 }
 
 TEST(StanMathOde_ode_adams, ts) {
@@ -120,15 +120,15 @@ TEST(StanMathOde_ode_adams, ts) {
 
   output[0][0].grad();
 
-  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+  EXPECT_NEAR(output[0][0].val(), 0.4165982112, 1e-5);
+  EXPECT_NEAR(ts[0].adj(), 0.78070695113, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[1][0].grad();
 
-  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
+  EXPECT_NEAR(output[1][0].val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(ts[1].adj(), -0.0791208888, 1e-5);
 }
 
 TEST(StanMathOde_ode_adams, ts_repeat) {
@@ -145,29 +145,29 @@ TEST(StanMathOde_ode_adams, ts_repeat) {
 
   output[0][0].grad();
 
-  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+  EXPECT_NEAR(output[0][0].val(), 0.4165982112, 1e-5);
+  EXPECT_NEAR(ts[0].adj(), 0.78070695113, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[1][0].grad();
 
-  EXPECT_FLOAT_EQ(output[1][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(ts[1].adj(), 0.78070695113);
+  EXPECT_NEAR(output[1][0].val(), 0.4165982112, 1e-5);
+  EXPECT_NEAR(ts[1].adj(), 0.78070695113, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[2][0].grad();
 
-  EXPECT_FLOAT_EQ(output[2][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(ts[2].adj(), -0.0791208888);
+  EXPECT_NEAR(output[2][0].val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(ts[2].adj(), -0.0791208888, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[3][0].grad();
 
-  EXPECT_FLOAT_EQ(output[3][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(ts[3].adj(), -0.0791208888);
+  EXPECT_NEAR(output[3][0].val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(ts[3].adj(), -0.0791208888, 1e-5);
 }
 
 TEST(StanMathOde_ode_adams, scalar_arg) {
@@ -183,8 +183,8 @@ TEST(StanMathOde_ode_adams, scalar_arg) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a.adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_adams, scalar_arg_multi_time) {
@@ -201,15 +201,15 @@ TEST(StanMathOde_ode_adams, scalar_arg_multi_time) {
 
   output[0](0).grad();
 
-  EXPECT_FLOAT_EQ(output[0](0).val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(a.adj(), -0.04352005542);
+  EXPECT_NEAR(output[0](0).val(), 0.4165982112, 1e-5);
+  EXPECT_NEAR(a.adj(), -0.04352005542, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[1](0).grad();
 
-  EXPECT_FLOAT_EQ(output[1](0).val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+  EXPECT_NEAR(output[1](0).val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a.adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_adams, std_vector_arg) {
@@ -225,8 +225,8 @@ TEST(StanMathOde_ode_adams, std_vector_arg) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a[0].adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a[0].adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_adams, vector_arg) {
@@ -243,8 +243,8 @@ TEST(StanMathOde_ode_adams, vector_arg) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a(0).adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_adams, row_vector_arg) {
@@ -261,8 +261,8 @@ TEST(StanMathOde_ode_adams, row_vector_arg) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a(0).adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_adams, matrix_arg) {
@@ -279,8 +279,8 @@ TEST(StanMathOde_ode_adams, matrix_arg) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a(0, 0).adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a(0, 0).adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_adams, scalar_std_vector_args) {
@@ -298,9 +298,92 @@ TEST(StanMathOde_ode_adams, scalar_std_vector_args) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a0.adj(), -0.50107310888);
-  EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a0.adj(), -0.50107310888, 1e-5);
+  EXPECT_NEAR(a1[0].adj(), -0.50107310888, 1e-5);
+}
+
+TEST(StanMathOde_ode_adams, std_vector_std_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 1.5;
+  std::vector<var> a1(1, a0);
+  std::vector<std::vector<var>> a2(1, a1);
+
+  var output
+      = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+
+  output.grad();
+
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a2[0][0].adj(), -0.50107310888, 1e-5);
+}
+
+TEST(StanMathOde_ode_adams, std_vector_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 1.5;
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a1(1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> a2(1, a1);
+
+  var output
+      = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+
+  output.grad();
+
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a2[0](0).adj(), -0.50107310888, 1e-5);
+}
+
+TEST(StanMathOde_ode_adams, std_vector_row_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 1.5;
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a1(1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> a2(1, a1);
+
+  var output
+      = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+
+  output.grad();
+
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a2[0](0).adj(), -0.50107310888, 1e-5);
+}
+
+TEST(StanMathOde_ode_adams, std_vector_matrix_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 1.5;
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a1(1, 1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> a2(1, a1);
+
+  var output
+      = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+
+  output.grad();
+
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a2[0](0).adj(), -0.50107310888, 1e-5);
 }
 
 struct ayt {
@@ -324,31 +407,31 @@ TEST(StanMathOde_ode_adams, arg_combos_test) {
   Eigen::VectorXd y0d = stan::math::value_of(y0);
 
   auto check_yT = [&](auto yT) {
-    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
-                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+    EXPECT_NEAR(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   auto check_t0 = [&](var t0) {
-    EXPECT_FLOAT_EQ(
+    EXPECT_NEAR(
         t0.adj(),
-        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   auto check_a = [&](var a) {
-    EXPECT_FLOAT_EQ(a.adj(),
+    EXPECT_NEAR(a.adj(),
                     -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
-                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   auto check_ts = [&](std::vector<var> ts) {
-    EXPECT_FLOAT_EQ(
+    EXPECT_NEAR(
         ts[0].adj(),
-        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
-    EXPECT_FLOAT_EQ(y0(0).adj(),
-                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+    EXPECT_NEAR(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   double yT1 = stan::math::ode_adams(ayt(), y0d, t0d, tsd, nullptr, ad)[0](0);
diff --git a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
index 39ddfd74534..cad840d8a83 100644
--- a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
@@ -73,18 +73,18 @@ TEST(ode_adams_tol_prim, y0_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, a));
+                                           1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0inf, t0, ts, 1e-10, 1e-10,
-                                         1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0NaN, t0, ts, 1e-10, 1e-10,
-                                         1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0_empty, t0, ts, 1e-10,
-                                         1e-10, 1e6, nullptr, a),
+                                        1e-10, 1e6, nullptr, a),
                std::invalid_argument);
 }
 
@@ -98,14 +98,14 @@ TEST(ode_adams_tol_prim, t0_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, a));
+                                           1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0inf, ts, 1e-10, 1e-10,
-                                         1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0NaN, ts, 1e-10, 1e-10,
-                                         1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -124,32 +124,32 @@ TEST(ode_adams_tol_prim, ts_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, a));
+                                           1e6, nullptr, a));
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
-                                            1e-10, 1e6, nullptr, a));
+                                           1e-10, 1e6, nullptr, a));
 
-  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
-                                            1e-10, 1e6, nullptr, a));
+    EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
+                                           1e-10, 1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
-                                         1e-10, 1e6, nullptr, a),
+                                        1e-10, 1e6, nullptr, a),
                std::invalid_argument);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_early, 1e-10,
-                                         1e-10, 1e6, nullptr, a),
+                                        1e-10, 1e6, nullptr, a),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_decreasing,
-                                         1e-10, 1e-10, 1e6, nullptr, a),
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_decreasing, 1e-10,
+                                        1e-10, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, tsinf, 1e-10, 1e-10,
-                                         1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, tsNaN, 1e-10, 1e-10,
-                                         1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -173,37 +173,67 @@ TEST(ode_adams_tol_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
+  std::vector<std::vector<double>> vva = { va };
+  std::vector<std::vector<double>> vvainf = { vainf };
+  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+
+  std::vector<Eigen::VectorXd> vea = { ea };
+  std::vector<Eigen::VectorXd> veainf = { eainf };
+  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, ainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, aNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, va));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, vainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, vaNaN),
+               std::domain_error);
+
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, a));
+                                           1e6, nullptr, ea));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                         1e6, nullptr, ainf),
+                                        1e6, nullptr, eainf),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                         1e6, nullptr, aNaN),
+                                        1e6, nullptr, eaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, va));
+                                           1e6, nullptr, vva));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                         1e6, nullptr, vainf),
+                                        1e6, nullptr, vvainf),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                         1e6, nullptr, vaNaN),
+                                        1e6, nullptr, vvaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, ea));
+                                           1e6, nullptr, vea));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                         1e6, nullptr, eainf),
+                                        1e6, nullptr, veainf),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                         1e6, nullptr, eaNaN),
+                                        1e6, nullptr, veaNaN),
                std::domain_error);
 }
 
@@ -227,37 +257,67 @@ TEST(ode_adams_tol_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
+  std::vector<std::vector<double>> vva = { va };
+  std::vector<std::vector<double>> vvainf = { vainf };
+  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+
+  std::vector<Eigen::VectorXd> vea = { ea };
+  std::vector<Eigen::VectorXd> veainf = { eainf };
+  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, a, a));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, ainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, aNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, a, va));
+
+  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, vainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, vaNaN),
+               std::domain_error);
+
   EXPECT_NO_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, a, a));
+                                           1e6, nullptr, a, ea));
 
   EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                         1e6, nullptr, a, ainf),
+                                        1e6, nullptr, a, eainf),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                         1e6, nullptr, a, aNaN),
+                                        1e6, nullptr, a, eaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, a, va));
+                                           1e6, nullptr, a, vva));
 
   EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                         1e6, nullptr, a, vainf),
+                                        1e6, nullptr, a, vvainf),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                         1e6, nullptr, a, vaNaN),
+                                        1e6, nullptr, a, vvaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, a, ea));
+                                           1e6, nullptr, a, vea));
 
   EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                         1e6, nullptr, a, eainf),
+                                        1e6, nullptr, a, veainf),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                         1e6, nullptr, a, eaNaN),
+                                        1e6, nullptr, a, veaNaN),
                std::domain_error);
 }
 
@@ -274,18 +334,18 @@ TEST(ode_adams_tol_prim, rtol_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, rtol, 1e-10,
-                                            1e6, nullptr, a));
+                                           1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, rtol_negative,
-                                         1e-10, 1e6, nullptr, a),
+                                        1e-10, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, rtolinf, 1e-10,
-                                         1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, rtolNaN, 1e-10,
-                                         1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -302,18 +362,18 @@ TEST(ode_adams_tol_prim, atol_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, atol,
-                                            1e6, nullptr, a));
+                                           1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6,
-                                         atol_negative, 1e6, nullptr, a),
+                                        atol_negative, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, atolinf,
-                                         1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, atolNaN,
-                                         1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -329,14 +389,14 @@ TEST(ode_adams_tol_prim, max_num_steps_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                            max_num_steps, nullptr, a));
+                                           max_num_steps, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                         max_num_steps_negative, nullptr, a),
+                                        max_num_steps_negative, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                         max_num_steps_zero, nullptr, a),
+                                        max_num_steps_zero, nullptr, a),
                std::domain_error);
 }
 
@@ -348,10 +408,10 @@ TEST(ode_adams_tol_prim, rhs_wrong_size_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                            100, nullptr, a));
+                                           100, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArgWrongSize(), y0, t0, ts, 1e-6,
-                                         1e-6, 100, nullptr, a),
+                                        1e-6, 100, nullptr, a),
                std::invalid_argument);
 }
 
@@ -363,6 +423,6 @@ TEST(ode_adams_tol_prim, error_name) {
   double ainf = stan::math::INFTY;
 
   EXPECT_THROW_MSG(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                             100, nullptr, ainf),
+                                            100, nullptr, ainf),
                    std::domain_error, "ode_adams_tol");
 }
diff --git a/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
index 5c9693e1ada..75cf2b0b538 100644
--- a/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
@@ -59,7 +59,7 @@ TEST(StanMathOde_ode_adams_tol, int_t0) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                  nullptr, a);
+                                 nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
   EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
@@ -76,7 +76,7 @@ TEST(StanMathOde_ode_adams_tol, int_ts) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                  nullptr, a);
+                                 nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
   EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
@@ -93,7 +93,7 @@ TEST(StanMathOde_ode_adams_tol, t0) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                  nullptr, a);
+                                 nullptr, a);
 
   output[0][0].grad();
 
@@ -119,7 +119,7 @@ TEST(StanMathOde_ode_adams_tol, ts) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                  nullptr, a);
+                                 nullptr, a);
 
   output[0][0].grad();
 
@@ -145,7 +145,7 @@ TEST(StanMathOde_ode_adams_tol, ts_repeat) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                  nullptr, a);
+                                 nullptr, a);
 
   output[0][0].grad();
 
@@ -183,8 +183,8 @@ TEST(StanMathOde_ode_adams_tol, scalar_arg) {
 
   var a = 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
-                                         1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -203,7 +203,7 @@ TEST(StanMathOde_ode_adams_tol, scalar_arg_multi_time) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                  nullptr, a);
+                                 nullptr, a);
 
   output[0](0).grad();
 
@@ -227,8 +227,8 @@ TEST(StanMathOde_ode_adams_tol, std_vector_arg) {
 
   std::vector<var> a = {1.5};
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
-                                         1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -246,8 +246,8 @@ TEST(StanMathOde_ode_adams_tol, vector_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
-                                         1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -265,8 +265,8 @@ TEST(StanMathOde_ode_adams_tol, row_vector_arg) {
   Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
-                                         1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -284,8 +284,8 @@ TEST(StanMathOde_ode_adams_tol, matrix_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
   a << 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
-                                         1e6, nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -303,8 +303,8 @@ TEST(StanMathOde_ode_adams_tol, scalar_std_vector_args) {
   var a0 = 0.75;
   std::vector<var> a1 = {0.75};
 
-  var output = stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10,
-                                         1e6, nullptr, a0, a1)[0][0];
+  var output = stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a0, a1)[0][0];
 
   output.grad();
 
@@ -313,350 +313,103 @@ TEST(StanMathOde_ode_adams_tol, scalar_std_vector_args) {
   EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
 }
 
-struct ayt {
-  template <typename T0, typename T1, typename T2>
-  inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1>
-  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
-             std::ostream* msgs, const T2& a) const {
-    return -a * y * t;
-  }
-};
-
-TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
-  var t0 = 0.5;
-  var a = 0.2;
-  std::vector<var> ts = {1.25};
-  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
-  y0 << 0.75;
-
-  double t0d = stan::math::value_of(t0);
-  double ad = stan::math::value_of(a);
-  std::vector<double> tsd = stan::math::value_of(ts);
-  Eigen::VectorXd y0d = stan::math::value_of(y0);
-
-  auto check_yT = [&](auto yT) {
-    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
-                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_t0 = [&](var t0) {
-    EXPECT_FLOAT_EQ(
-        t0.adj(),
-        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_a = [&](var a) {
-    EXPECT_FLOAT_EQ(a.adj(),
-                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
-                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_ts = [&](std::vector<var> ts) {
-    EXPECT_FLOAT_EQ(
-        ts[0].adj(),
-        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
-    EXPECT_FLOAT_EQ(y0(0).adj(),
-                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  double yT1 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                         1e6, nullptr, ad)[0](0);
-  check_yT(yT1);
-
-  var yT2 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT2.grad();
-  check_yT(yT2);
-  check_a(a);
-
-  var yT3 = stan::math::ode_adams_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT3.grad();
-  check_yT(yT3);
-  check_ts(ts);
-
-  var yT4 = stan::math::ode_adams_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT4.grad();
-  check_yT(yT4);
-  check_ts(ts);
-  check_a(a);
-
-  var yT5 = stan::math::ode_adams_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT5.grad();
-  check_yT(yT5);
-  check_t0(t0);
-
-  var yT6 = stan::math::ode_adams_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT6.grad();
-  check_yT(yT6);
-  check_t0(t0);
-  check_a(a);
-
-  var yT7 = stan::math::ode_adams_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT7.grad();
-  check_yT(yT7);
-  check_t0(t0);
-  check_ts(ts);
-
-  var yT8 = stan::math::ode_adams_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT8.grad();
-  check_yT(yT8);
-  check_t0(t0);
-  check_ts(ts);
-  check_a(a);
-
-  var yT9 = stan::math::ode_adams_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT9.grad();
-  check_yT(yT9);
-  check_y0(y0);
-
-  var yT10 = stan::math::ode_adams_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                       nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT10.grad();
-  check_yT(yT10);
-  check_y0(y0);
-  check_a(a);
-
-  var yT11 = stan::math::ode_adams_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT11.grad();
-  check_yT(yT11);
-  check_y0(y0);
-  check_ts(ts);
+TEST(StanMathOde_ode_adams_tol, std_vector_std_vector_args) {
+  using stan::math::var;
 
-  var yT12 = stan::math::ode_adams_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT12.grad();
-  check_yT(yT12);
-  check_y0(y0);
-  check_ts(ts);
-  check_a(a);
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
 
-  var yT13 = stan::math::ode_adams_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                       nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT13.grad();
-  check_yT(yT13);
-  check_y0(y0);
-  check_t0(t0);
+  var a0 = 1.5;
+  std::vector<var> a1(1, a0);
+  std::vector<std::vector<var>> a2(1, a1);
 
-  var yT14 = stan::math::ode_adams_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                       nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT14.grad();
-  check_yT(yT14);
-  check_y0(y0);
-  check_t0(t0);
-  check_a(a);
+  var output
+    = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+			       nullptr, a2)[0][0];
 
-  var yT15 = stan::math::ode_adams_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT15.grad();
-  check_yT(yT15);
-  check_y0(y0);
-  check_t0(t0);
-  check_ts(ts);
+  output.grad();
 
-  var yT16 = stan::math::ode_adams_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT16.grad();
-  check_yT(yT16);
-  check_y0(y0);
-  check_t0(t0);
-  check_ts(ts);
-  check_a(a);
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a2[0][0].adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_adams_tol, arg_combos_error_test) {
-  var t0 = 0.5;
-  var a = 0.2;
-  std::vector<var> ts = {1.25};
-  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
-  y0 << 0.75;
-
-  double t0d = stan::math::value_of(t0);
-  double ad = stan::math::value_of(a);
-  std::vector<double> tsd = stan::math::value_of(ts);
-  Eigen::VectorXd y0d = stan::math::value_of(y0);
-
-  auto check_yT = [&](auto yT) {
-    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
-                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_t0 = [&](var t0) {
-    EXPECT_FLOAT_EQ(
-        t0.adj(),
-        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_a = [&](var a) {
-    EXPECT_FLOAT_EQ(a.adj(),
-                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
-                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_ts = [&](std::vector<var> ts) {
-    EXPECT_FLOAT_EQ(
-        ts[0].adj(),
-        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
+TEST(StanMathOde_ode_adams_tol, std_vector_vector_args) {
+  using stan::math::var;
 
-  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
-    EXPECT_FLOAT_EQ(y0(0).adj(),
-                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
 
-  double yT1 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, tsd, 1e-10,
-                                               1e-10, 1e6, nullptr, ad)[0](0);
-  check_yT(yT1);
+  var a0 = 1.5;
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a1(1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> a2(1, a1);
 
-  var yT2 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                            1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT2.grad();
-  check_yT(yT2);
-  check_a(a);
+  var output
+    = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+			       nullptr, a2)[0][0];
 
-  var yT3 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT3.grad();
-  check_yT(yT3);
-  check_ts(ts);
+  output.grad();
 
-  var yT4 = stan::math::ode_adams_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT4.grad();
-  check_yT(yT4);
-  check_ts(ts);
-  check_a(a);
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a2[0](0).adj(), -0.50107310888);
+}
 
-  var yT5 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
-                                            1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT5.grad();
-  check_yT(yT5);
-  check_t0(t0);
+TEST(StanMathOde_ode_adams_tol, std_vector_row_vector_args) {
+  using stan::math::var;
 
-  var yT6 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
-                                            1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT6.grad();
-  check_yT(yT6);
-  check_t0(t0);
-  check_a(a);
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
 
-  var yT7 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT7.grad();
-  check_yT(yT7);
-  check_t0(t0);
-  check_ts(ts);
+  var a0 = 1.5;
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a1(1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> a2(1, a1);
 
-  var yT8 = stan::math::ode_adams_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT8.grad();
-  check_yT(yT8);
-  check_t0(t0);
-  check_ts(ts);
-  check_a(a);
+  var output
+    = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+			       nullptr, a2)[0][0];
 
-  var yT9 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
-                                            1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT9.grad();
-  check_yT(yT9);
-  check_y0(y0);
+  output.grad();
 
-  var yT10 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
-                                             1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT10.grad();
-  check_yT(yT10);
-  check_y0(y0);
-  check_a(a);
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a2[0](0).adj(), -0.50107310888);
+}
 
-  var yT11 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
-                                             1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT11.grad();
-  check_yT(yT11);
-  check_y0(y0);
-  check_ts(ts);
+TEST(StanMathOde_ode_adams_tol, std_vector_matrix_args) {
+  using stan::math::var;
 
-  var yT12 = stan::math::ode_adams_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
-                                             1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT12.grad();
-  check_yT(yT12);
-  check_y0(y0);
-  check_ts(ts);
-  check_a(a);
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
 
-  var yT13 = stan::math::ode_adams_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
-                                             1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT13.grad();
-  check_yT(yT13);
-  check_y0(y0);
-  check_t0(t0);
+  var a0 = 1.5;
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a1(1, 1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> a2(1, a1);
 
-  var yT14 = stan::math::ode_adams_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
-                                             1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT14.grad();
-  check_yT(yT14);
-  check_y0(y0);
-  check_t0(t0);
-  check_a(a);
+  var output
+    = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+			       nullptr, a2)[0][0];
 
-  var yT15 = stan::math::ode_adams_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10,
-                                             1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT15.grad();
-  check_yT(yT15);
-  check_y0(y0);
-  check_t0(t0);
-  check_ts(ts);
+  output.grad();
 
-  var yT16 = stan::math::ode_adams_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10,
-                                             1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT16.grad();
-  check_yT(yT16);
-  check_y0(y0);
-  check_t0(t0);
-  check_ts(ts);
-  check_a(a);
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a2[0](0).adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
+struct ayt {
+  template <typename T0, typename T1, typename T2>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a) const {
+    return -a * y * t;
+  }
+};
+
+TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   var t0 = 0.5;
   var a = 0.2;
   std::vector<var> ts = {1.25};
@@ -696,59 +449,57 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
                     exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
-  double yT1 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {}, 1e6, nullptr, ad)[0](0);
+  double yT1 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                        nullptr, ad)[0](0);
   check_yT(yT1);
 
-  var yT2 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, a)[0](0);
+  var yT2 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
-  var yT3 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {}, 1e6, nullptr, ad)[0](0);
+  var yT3 = stan::math::ode_adams_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
-  var yT4 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, a)[0](0);
+  var yT4 = stan::math::ode_adams_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
   check_ts(ts);
   check_a(a);
 
-  var yT5 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT5 = stan::math::ode_adams_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
-  var yT6 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10,
-                                                 1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
-                                                 nullptr, a)[0](0);
+  var yT6 = stan::math::ode_adams_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
   check_t0(t0);
   check_a(a);
 
-  var yT7 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT7 = stan::math::ode_adams_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
   check_t0(t0);
   check_ts(ts);
 
-  var yT8 = stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0, ts, 1e-10,
-                                                 1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
-                                                 nullptr, a)[0](0);
+  var yT8 = stan::math::ode_adams_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -756,33 +507,31 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT9 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT9 = stan::math::ode_adams_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
-  var yT10 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10,
-                                                  1e-10, 1e-6, {1e-6, 1e-6},
-                                                  1e6, nullptr, a)[0](0);
+  var yT10 = stan::math::ode_adams_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
   check_y0(y0);
   check_a(a);
 
-  var yT11 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT11 = stan::math::ode_adams_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
   check_y0(y0);
   check_ts(ts);
 
-  var yT12 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0d, ts, 1e-10,
-                                                  1e-10, 1e-6, {1e-6, 1e-6},
-                                                  1e6, nullptr, a)[0](0);
+  var yT12 = stan::math::ode_adams_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -790,17 +539,16 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT13 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT13 = stan::math::ode_adams_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
   check_y0(y0);
   check_t0(t0);
 
-  var yT14 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, tsd, 1e-10,
-                                                  1e-10, 1e-6, {1e-6, 1e-6},
-                                                  1e6, nullptr, a)[0](0);
+  var yT14 = stan::math::ode_adams_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -808,8 +556,8 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_t0(t0);
   check_a(a);
 
-  var yT15 = stan::math::ode_adams_tol_sens_error(
-      ayt(), y0, t0, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT15 = stan::math::ode_adams_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -817,9 +565,8 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_t0(t0);
   check_ts(ts);
 
-  var yT16 = stan::math::ode_adams_tol_sens_error(ayt(), y0, t0, ts, 1e-10,
-                                                  1e-10, 1e-6, {1e-6, 1e-6},
-                                                  1e6, nullptr, a)[0](0);
+  var yT16 = stan::math::ode_adams_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
@@ -827,19 +574,4 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_sens_error_test) {
   check_t0(t0);
   check_ts(ts);
   check_a(a);
-
-  EXPECT_THROW(
-      stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                           1e-6, {1e-6, 1e-6}, 1e6, nullptr, a),
-      std::invalid_argument);
-
-  EXPECT_THROW(
-      stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                           -1e-6, {1e-6}, 1e6, nullptr, a),
-      std::domain_error);
-
-  EXPECT_THROW(
-      stan::math::ode_adams_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                           -1e-6, {-1e-6}, 1e6, nullptr, a),
-      std::domain_error);
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index 8f39d5e4843..4da34dc7c7d 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -161,6 +161,14 @@ TEST(ode_bdf_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
+  std::vector<std::vector<double>> vva = { va };
+  std::vector<std::vector<double>> vvainf = { vainf };
+  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+
+  std::vector<Eigen::VectorXd> vea = { ea };
+  std::vector<Eigen::VectorXd> veainf = { eainf };
+  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+
   EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, ainf),
@@ -184,6 +192,22 @@ TEST(ode_bdf_prim, one_arg_errors) {
 
   EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, eaNaN),
                std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, vva));
+
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, vvainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, vvaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, vea));
+
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, veainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, veaNaN),
+               std::domain_error);
 }
 
 TEST(ode_bdf_prim, two_arg_errors) {
@@ -206,6 +230,14 @@ TEST(ode_bdf_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
+  std::vector<std::vector<double>> vva = { va };
+  std::vector<std::vector<double>> vvainf = { vainf };
+  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+
+  std::vector<Eigen::VectorXd> vea = { ea };
+  std::vector<Eigen::VectorXd> veainf = { eainf };
+  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+
   EXPECT_NO_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, a));
 
   EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, ainf),
@@ -229,6 +261,22 @@ TEST(ode_bdf_prim, two_arg_errors) {
 
   EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, eaNaN),
                std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, vva));
+
+  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, vvainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, vvaNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, vea));
+
+  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, veainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, veaNaN),
+               std::domain_error);
 }
 
 TEST(ode_bdf_prim, rhs_wrong_size_errors) {
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index 9c6284f8a6e..4bf8af11883 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -61,8 +61,8 @@ TEST(StanMathOde_ode_bdf, int_t0) {
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a);
 
-  EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
-  EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
+  EXPECT_NEAR(output[0][0], 0.4165982112, 1e-5);
+  EXPECT_NEAR(output[1][0], 0.66457668563, 1e-5);
 }
 
 TEST(StanMathOde_ode_bdf, int_ts) {
@@ -77,8 +77,8 @@ TEST(StanMathOde_ode_bdf, int_ts) {
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a);
 
-  EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
-  EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
+  EXPECT_NEAR(output[0][0], 0.6649966577, 1e-5);
+  EXPECT_NEAR(output[1][0], 0.09408000537, 1e-5);
 }
 
 TEST(StanMathOde_ode_bdf, t0) {
@@ -95,15 +95,15 @@ TEST(StanMathOde_ode_bdf, t0) {
 
   output[0][0].grad();
 
-  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+  EXPECT_NEAR(output[0][0].val(), 0.4165982112, 1e-5);
+  EXPECT_NEAR(t0.adj(), -1.0, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[1][0].grad();
 
-  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+  EXPECT_NEAR(output[1][0].val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(t0.adj(), -1.0, 1e-5);
 }
 
 TEST(StanMathOde_ode_bdf, ts) {
@@ -120,15 +120,15 @@ TEST(StanMathOde_ode_bdf, ts) {
 
   output[0][0].grad();
 
-  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+  EXPECT_NEAR(output[0][0].val(), 0.4165982112, 1e-5);
+  EXPECT_NEAR(ts[0].adj(), 0.78070695113, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[1][0].grad();
 
-  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
+  EXPECT_NEAR(output[1][0].val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(ts[1].adj(), -0.0791208888, 1e-5);
 }
 
 TEST(StanMathOde_ode_bdf, ts_repeat) {
@@ -145,29 +145,29 @@ TEST(StanMathOde_ode_bdf, ts_repeat) {
 
   output[0][0].grad();
 
-  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+  EXPECT_NEAR(output[0][0].val(), 0.4165982112, 1e-5);
+  EXPECT_NEAR(ts[0].adj(), 0.78070695113, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[1][0].grad();
 
-  EXPECT_FLOAT_EQ(output[1][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(ts[1].adj(), 0.78070695113);
+  EXPECT_NEAR(output[1][0].val(), 0.4165982112, 1e-5);
+  EXPECT_NEAR(ts[1].adj(), 0.78070695113, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[2][0].grad();
 
-  EXPECT_FLOAT_EQ(output[2][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(ts[2].adj(), -0.0791208888);
+  EXPECT_NEAR(output[2][0].val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(ts[2].adj(), -0.0791208888, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[3][0].grad();
 
-  EXPECT_FLOAT_EQ(output[3][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(ts[3].adj(), -0.0791208888);
+  EXPECT_NEAR(output[3][0].val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(ts[3].adj(), -0.0791208888, 1e-5);
 }
 
 TEST(StanMathOde_ode_bdf, scalar_arg) {
@@ -183,8 +183,8 @@ TEST(StanMathOde_ode_bdf, scalar_arg) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a.adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_bdf, scalar_arg_multi_time) {
@@ -201,15 +201,15 @@ TEST(StanMathOde_ode_bdf, scalar_arg_multi_time) {
 
   output[0](0).grad();
 
-  EXPECT_FLOAT_EQ(output[0](0).val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(a.adj(), -0.04352005542);
+  EXPECT_NEAR(output[0](0).val(), 0.4165982112, 1e-5);
+  EXPECT_NEAR(a.adj(), -0.04352005542, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[1](0).grad();
 
-  EXPECT_FLOAT_EQ(output[1](0).val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+  EXPECT_NEAR(output[1](0).val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a.adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_bdf, std_vector_arg) {
@@ -225,8 +225,8 @@ TEST(StanMathOde_ode_bdf, std_vector_arg) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a[0].adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a[0].adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_bdf, vector_arg) {
@@ -243,8 +243,8 @@ TEST(StanMathOde_ode_bdf, vector_arg) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a(0).adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_bdf, row_vector_arg) {
@@ -261,8 +261,8 @@ TEST(StanMathOde_ode_bdf, row_vector_arg) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a(0).adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_bdf, matrix_arg) {
@@ -279,8 +279,8 @@ TEST(StanMathOde_ode_bdf, matrix_arg) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a(0, 0).adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a(0, 0).adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_bdf, scalar_std_vector_args) {
@@ -298,9 +298,92 @@ TEST(StanMathOde_ode_bdf, scalar_std_vector_args) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a0.adj(), -0.50107310888);
-  EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a0.adj(), -0.50107310888, 1e-5);
+  EXPECT_NEAR(a1[0].adj(), -0.50107310888, 1e-5);
+}
+
+TEST(StanMathOde_ode_bdf, std_vector_std_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 1.5;
+  std::vector<var> a1(1, a0);
+  std::vector<std::vector<var>> a2(1, a1);
+
+  var output
+    = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+
+  output.grad();
+
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a2[0][0].adj(), -0.50107310888, 1e-5);
+}
+
+TEST(StanMathOde_ode_bdf, std_vector_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 1.5;
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a1(1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> a2(1, a1);
+
+  var output
+    = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+
+  output.grad();
+
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a2[0](0).adj(), -0.50107310888, 1e-5);
+}
+
+TEST(StanMathOde_ode_bdf, std_vector_row_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 1.5;
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a1(1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> a2(1, a1);
+
+  var output
+    = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+
+  output.grad();
+
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a2[0](0).adj(), -0.50107310888, 1e-5);
+}
+
+TEST(StanMathOde_ode_bdf, std_vector_matrix_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 1.5;
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a1(1, 1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> a2(1, a1);
+
+  var output
+    = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+
+  output.grad();
+
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a2[0](0).adj(), -0.50107310888, 1e-5);
 }
 
 struct ayt {
@@ -324,31 +407,31 @@ TEST(StanMathOde_ode_bdf, arg_combos_test) {
   Eigen::VectorXd y0d = stan::math::value_of(y0);
 
   auto check_yT = [&](auto yT) {
-    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
-                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+    EXPECT_NEAR(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   auto check_t0 = [&](var t0) {
-    EXPECT_FLOAT_EQ(
+    EXPECT_NEAR(
         t0.adj(),
-        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   auto check_a = [&](var a) {
-    EXPECT_FLOAT_EQ(a.adj(),
+    EXPECT_NEAR(a.adj(),
                     -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
-                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   auto check_ts = [&](std::vector<var> ts) {
-    EXPECT_FLOAT_EQ(
+    EXPECT_NEAR(
         ts[0].adj(),
-        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
-    EXPECT_FLOAT_EQ(y0(0).adj(),
-                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+    EXPECT_NEAR(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   double yT1 = stan::math::ode_bdf(ayt(), y0d, t0d, tsd, nullptr, ad)[0](0);
diff --git a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
index cc7139e0b13..85765824ea8 100644
--- a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
@@ -73,18 +73,18 @@ TEST(ode_bdf_tol_prim, y0_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+                                           1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0inf, t0, ts, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0NaN, t0, ts, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0_empty, t0, ts, 1e-10,
-                                       1e-10, 1e6, nullptr, a),
+                                        1e-10, 1e6, nullptr, a),
                std::invalid_argument);
 }
 
@@ -98,14 +98,14 @@ TEST(ode_bdf_tol_prim, t0_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+                                           1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0inf, ts, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0NaN, ts, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -124,32 +124,32 @@ TEST(ode_bdf_tol_prim, ts_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+                                           1e6, nullptr, a));
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
-                                          1e-10, 1e6, nullptr, a));
+                                           1e-10, 1e6, nullptr, a));
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
-                                          1e-10, 1e6, nullptr, a));
+    EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
+                                           1e-10, 1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
-                                       1e-10, 1e6, nullptr, a),
+                                        1e-10, 1e6, nullptr, a),
                std::invalid_argument);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_early, 1e-10,
-                                       1e-10, 1e6, nullptr, a),
+                                        1e-10, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_decreasing, 1e-10,
-                                       1e-10, 1e6, nullptr, a),
+                                        1e-10, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, tsinf, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, tsNaN, 1e-10, 1e-10,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -173,37 +173,67 @@ TEST(ode_bdf_tol_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
+  std::vector<std::vector<double>> vva = { va };
+  std::vector<std::vector<double>> vvainf = { vainf };
+  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+
+  std::vector<Eigen::VectorXd> vea = { ea };
+  std::vector<Eigen::VectorXd> veainf = { eainf };
+  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, ainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, aNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, va));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, vainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, vaNaN),
+               std::domain_error);
+
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+                                           1e6, nullptr, ea));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, ainf),
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, eainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, aNaN),
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, eaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, va));
+                                           1e6, nullptr, vva));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, vainf),
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, vvainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, vaNaN),
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, vvaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, ea));
+                                           1e6, nullptr, vea));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, eainf),
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, veainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, eaNaN),
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, veaNaN),
                std::domain_error);
 }
 
@@ -227,37 +257,67 @@ TEST(ode_bdf_tol_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
+  std::vector<std::vector<double>> vva = { va };
+  std::vector<std::vector<double>> vvainf = { vainf };
+  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+
+  std::vector<Eigen::VectorXd> vea = { ea };
+  std::vector<Eigen::VectorXd> veainf = { eainf };
+  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, a, a));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, ainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, aNaN),
+               std::domain_error);
+
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, a, va));
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, vainf),
+               std::domain_error);
+
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, vaNaN),
+               std::domain_error);
+
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a, a));
+                                           1e6, nullptr, a, ea));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, ainf),
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, eainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, aNaN),
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, eaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a, va));
+                                           1e6, nullptr, a, vva));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, vainf),
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, vvainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, vaNaN),
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, vvaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a, ea));
+                                           1e6, nullptr, a, vea));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, eainf),
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, veainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                       nullptr, a, eaNaN),
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
+                                        1e6, nullptr, a, veaNaN),
                std::domain_error);
 }
 
@@ -274,18 +334,18 @@ TEST(ode_bdf_tol_prim, rtol_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtol, 1e-10,
-                                          1e6, nullptr, a));
+                                           1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtol_negative,
-                                       1e-10, 1e6, nullptr, a),
+                                        1e-10, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtolinf, 1e-10,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtolNaN, 1e-10,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -302,18 +362,18 @@ TEST(ode_bdf_tol_prim, atol_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atol,
-                                          1e6, nullptr, a));
+                                           1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6,
-                                       atol_negative, 1e6, nullptr, a),
+                                        atol_negative, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atolinf,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atolNaN,
-                                       1e6, nullptr, a),
+                                        1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -329,14 +389,14 @@ TEST(ode_bdf_tol_prim, max_num_steps_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                          max_num_steps, nullptr, a));
+                                           max_num_steps, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                       max_num_steps_negative, nullptr, a),
+                                        max_num_steps_negative, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                       max_num_steps_zero, nullptr, a),
+                                        max_num_steps_zero, nullptr, a),
                std::domain_error);
 }
 
@@ -348,10 +408,10 @@ TEST(ode_bdf_tol_prim, rhs_wrong_size_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                          100, nullptr, a));
+                                           100, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArgWrongSize(), y0, t0, ts, 1e-6,
-                                       1e-6, 100, nullptr, a),
+                                        1e-6, 100, nullptr, a),
                std::invalid_argument);
 }
 
@@ -363,6 +423,6 @@ TEST(ode_bdf_tol_prim, error_name) {
   double ainf = stan::math::INFTY;
 
   EXPECT_THROW_MSG(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                           100, nullptr, ainf),
+                                            100, nullptr, ainf),
                    std::domain_error, "ode_bdf_tol");
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
index f88e442711a..672582e8490 100644
--- a/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
@@ -59,7 +59,7 @@ TEST(StanMathOde_ode_bdf_tol, int_t0) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                 nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
   EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
@@ -76,7 +76,7 @@ TEST(StanMathOde_ode_bdf_tol, int_ts) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                 nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
   EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
@@ -93,7 +93,7 @@ TEST(StanMathOde_ode_bdf_tol, t0) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                 nullptr, a);
 
   output[0][0].grad();
 
@@ -119,7 +119,7 @@ TEST(StanMathOde_ode_bdf_tol, ts) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                 nullptr, a);
 
   output[0][0].grad();
 
@@ -145,7 +145,7 @@ TEST(StanMathOde_ode_bdf_tol, ts_repeat) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                 nullptr, a);
 
   output[0][0].grad();
 
@@ -184,7 +184,7 @@ TEST(StanMathOde_ode_bdf_tol, scalar_arg) {
   var a = 1.5;
 
   var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -203,7 +203,7 @@ TEST(StanMathOde_ode_bdf_tol, scalar_arg_multi_time) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                nullptr, a);
+                                 nullptr, a);
 
   output[0](0).grad();
 
@@ -228,7 +228,7 @@ TEST(StanMathOde_ode_bdf_tol, std_vector_arg) {
   std::vector<var> a = {1.5};
 
   var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -247,7 +247,7 @@ TEST(StanMathOde_ode_bdf_tol, vector_arg) {
   a << 1.5;
 
   var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -266,7 +266,7 @@ TEST(StanMathOde_ode_bdf_tol, row_vector_arg) {
   a << 1.5;
 
   var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -285,7 +285,7 @@ TEST(StanMathOde_ode_bdf_tol, matrix_arg) {
   a << 1.5;
 
   var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a)[0][0];
+                                        nullptr, a)[0][0];
 
   output.grad();
 
@@ -304,7 +304,7 @@ TEST(StanMathOde_ode_bdf_tol, scalar_std_vector_args) {
   std::vector<var> a1 = {0.75};
 
   var output = stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                       nullptr, a0, a1)[0][0];
+                                        nullptr, a0, a1)[0][0];
 
   output.grad();
 
@@ -313,350 +313,103 @@ TEST(StanMathOde_ode_bdf_tol, scalar_std_vector_args) {
   EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
 }
 
-struct ayt {
-  template <typename T0, typename T1, typename T2>
-  inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1>
-  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
-             std::ostream* msgs, const T2& a) const {
-    return -a * y * t;
-  }
-};
-
-TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
-  var t0 = 0.5;
-  var a = 0.2;
-  std::vector<var> ts = {1.25};
-  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
-  y0 << 0.75;
-
-  double t0d = stan::math::value_of(t0);
-  double ad = stan::math::value_of(a);
-  std::vector<double> tsd = stan::math::value_of(ts);
-  Eigen::VectorXd y0d = stan::math::value_of(y0);
-
-  auto check_yT = [&](auto yT) {
-    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
-                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_t0 = [&](var t0) {
-    EXPECT_FLOAT_EQ(
-        t0.adj(),
-        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_a = [&](var a) {
-    EXPECT_FLOAT_EQ(a.adj(),
-                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
-                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_ts = [&](std::vector<var> ts) {
-    EXPECT_FLOAT_EQ(
-        ts[0].adj(),
-        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
-    EXPECT_FLOAT_EQ(y0(0).adj(),
-                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  double yT1 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                       nullptr, ad)[0](0);
-  check_yT(yT1);
-
-  var yT2 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT2.grad();
-  check_yT(yT2);
-  check_a(a);
-
-  var yT3 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT3.grad();
-  check_yT(yT3);
-  check_ts(ts);
-
-  var yT4 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT4.grad();
-  check_yT(yT4);
-  check_ts(ts);
-  check_a(a);
-
-  var yT5 = stan::math::ode_bdf_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT5.grad();
-  check_yT(yT5);
-  check_t0(t0);
-
-  var yT6 = stan::math::ode_bdf_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT6.grad();
-  check_yT(yT6);
-  check_t0(t0);
-  check_a(a);
-
-  var yT7 = stan::math::ode_bdf_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT7.grad();
-  check_yT(yT7);
-  check_t0(t0);
-  check_ts(ts);
-
-  var yT8 = stan::math::ode_bdf_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                    nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT8.grad();
-  check_yT(yT8);
-  check_t0(t0);
-  check_ts(ts);
-  check_a(a);
-
-  var yT9 = stan::math::ode_bdf_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                    nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT9.grad();
-  check_yT(yT9);
-  check_y0(y0);
-
-  var yT10 = stan::math::ode_bdf_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT10.grad();
-  check_yT(yT10);
-  check_y0(y0);
-  check_a(a);
-
-  var yT11 = stan::math::ode_bdf_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT11.grad();
-  check_yT(yT11);
-  check_y0(y0);
-  check_ts(ts);
+TEST(StanMathOde_ode_bdf_tol, std_vector_std_vector_args) {
+  using stan::math::var;
 
-  var yT12 = stan::math::ode_bdf_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT12.grad();
-  check_yT(yT12);
-  check_y0(y0);
-  check_ts(ts);
-  check_a(a);
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
 
-  var yT13 = stan::math::ode_bdf_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT13.grad();
-  check_yT(yT13);
-  check_y0(y0);
-  check_t0(t0);
+  var a0 = 1.5;
+  std::vector<var> a1(1, a0);
+  std::vector<std::vector<var>> a2(1, a1);
 
-  var yT14 = stan::math::ode_bdf_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT14.grad();
-  check_yT(yT14);
-  check_y0(y0);
-  check_t0(t0);
-  check_a(a);
+  var output
+    = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+			       nullptr, a2)[0][0];
 
-  var yT15 = stan::math::ode_bdf_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT15.grad();
-  check_yT(yT15);
-  check_y0(y0);
-  check_t0(t0);
-  check_ts(ts);
+  output.grad();
 
-  var yT16 = stan::math::ode_bdf_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT16.grad();
-  check_yT(yT16);
-  check_y0(y0);
-  check_t0(t0);
-  check_ts(ts);
-  check_a(a);
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a2[0][0].adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_bdf_tol, arg_combos_error_test) {
-  var t0 = 0.5;
-  var a = 0.2;
-  std::vector<var> ts = {1.25};
-  Eigen::Matrix<var, Eigen::Dynamic, 1> y0(1);
-  y0 << 0.75;
-
-  double t0d = stan::math::value_of(t0);
-  double ad = stan::math::value_of(a);
-  std::vector<double> tsd = stan::math::value_of(ts);
-  Eigen::VectorXd y0d = stan::math::value_of(y0);
-
-  auto check_yT = [&](auto yT) {
-    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
-                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_t0 = [&](var t0) {
-    EXPECT_FLOAT_EQ(
-        t0.adj(),
-        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_a = [&](var a) {
-    EXPECT_FLOAT_EQ(a.adj(),
-                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
-                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
-
-  auto check_ts = [&](std::vector<var> ts) {
-    EXPECT_FLOAT_EQ(
-        ts[0].adj(),
-        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
+TEST(StanMathOde_ode_bdf_tol, std_vector_vector_args) {
+  using stan::math::var;
 
-  auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
-    EXPECT_FLOAT_EQ(y0(0).adj(),
-                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
-  };
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
 
-  double yT1 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                             1e6, nullptr, ad)[0](0);
-  check_yT(yT1);
+  var a0 = 1.5;
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a1(1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> a2(1, a1);
 
-  var yT2 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                          1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT2.grad();
-  check_yT(yT2);
-  check_a(a);
+  var output
+    = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+			       nullptr, a2)[0][0];
 
-  var yT3 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT3.grad();
-  check_yT(yT3);
-  check_ts(ts);
+  output.grad();
 
-  var yT4 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0d, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT4.grad();
-  check_yT(yT4);
-  check_ts(ts);
-  check_a(a);
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a2[0](0).adj(), -0.50107310888);
+}
 
-  var yT5 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
-                                          1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT5.grad();
-  check_yT(yT5);
-  check_t0(t0);
+TEST(StanMathOde_ode_bdf_tol, std_vector_row_vector_args) {
+  using stan::math::var;
 
-  var yT6 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, tsd, 1e-10, 1e-10,
-                                          1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT6.grad();
-  check_yT(yT6);
-  check_t0(t0);
-  check_a(a);
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
 
-  var yT7 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                          nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT7.grad();
-  check_yT(yT7);
-  check_t0(t0);
-  check_ts(ts);
+  var a0 = 1.5;
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a1(1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> a2(1, a1);
 
-  var yT8 = stan::math::ode_bdf_tol_error(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                          nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT8.grad();
-  check_yT(yT8);
-  check_t0(t0);
-  check_ts(ts);
-  check_a(a);
+  var output
+    = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+			       nullptr, a2)[0][0];
 
-  var yT9 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
-                                          1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT9.grad();
-  check_yT(yT9);
-  check_y0(y0);
+  output.grad();
 
-  var yT10 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, tsd, 1e-10, 1e-10,
-                                           1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT10.grad();
-  check_yT(yT10);
-  check_y0(y0);
-  check_a(a);
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a2[0](0).adj(), -0.50107310888);
+}
 
-  var yT11 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT11.grad();
-  check_yT(yT11);
-  check_y0(y0);
-  check_ts(ts);
+TEST(StanMathOde_ode_bdf_tol, std_vector_matrix_args) {
+  using stan::math::var;
 
-  var yT12 = stan::math::ode_bdf_tol_error(ayt(), y0, t0d, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT12.grad();
-  check_yT(yT12);
-  check_y0(y0);
-  check_ts(ts);
-  check_a(a);
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
 
-  var yT13 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
-                                           1e6, nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT13.grad();
-  check_yT(yT13);
-  check_y0(y0);
-  check_t0(t0);
+  var a0 = 1.5;
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a1(1, 1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> a2(1, a1);
 
-  var yT14 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, tsd, 1e-10, 1e-10,
-                                           1e6, nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT14.grad();
-  check_yT(yT14);
-  check_y0(y0);
-  check_t0(t0);
-  check_a(a);
+  var output
+    = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+			       nullptr, a2)[0][0];
 
-  var yT15 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                           nullptr, ad)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT15.grad();
-  check_yT(yT15);
-  check_y0(y0);
-  check_t0(t0);
-  check_ts(ts);
+  output.grad();
 
-  var yT16 = stan::math::ode_bdf_tol_error(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                           nullptr, a)[0](0);
-  stan::math::set_zero_all_adjoints();
-  yT16.grad();
-  check_yT(yT16);
-  check_y0(y0);
-  check_t0(t0);
-  check_ts(ts);
-  check_a(a);
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a2[0](0).adj(), -0.50107310888);
 }
 
-TEST(StanMathOde_ode_bdf_tol, arg_combos_sens_error_test) {
+struct ayt {
+  template <typename T0, typename T1, typename T2>
+  inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y,
+             std::ostream* msgs, const T2& a) const {
+    return -a * y * t;
+  }
+};
+
+TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   var t0 = 0.5;
   var a = 0.2;
   std::vector<var> ts = {1.25};
@@ -696,59 +449,57 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_sens_error_test) {
                     exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
-  double yT1 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {}, 1e6, nullptr, ad)[0](0);
+  double yT1 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                        nullptr, ad)[0](0);
   check_yT(yT1);
 
-  var yT2 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, a)[0](0);
+  var yT2 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
-  var yT3 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {}, 1e6, nullptr, ad)[0](0);
+  var yT3 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
-  var yT4 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, a)[0](0);
+  var yT4 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
   check_ts(ts);
   check_a(a);
 
-  var yT5 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT5 = stan::math::ode_bdf_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
-  var yT6 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0, tsd, 1e-10,
-                                               1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
-                                               nullptr, a)[0](0);
+  var yT6 = stan::math::ode_bdf_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
   check_t0(t0);
   check_a(a);
 
-  var yT7 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT7 = stan::math::ode_bdf_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
   check_t0(t0);
   check_ts(ts);
 
-  var yT8 = stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0, ts, 1e-10, 1e-10,
-                                               1e-6, {1e-6, 1e-6}, 1e6, nullptr,
-                                               a)[0](0);
+  var yT8 = stan::math::ode_bdf_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -756,33 +507,31 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_sens_error_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT9 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT9 = stan::math::ode_bdf_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
-  var yT10 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0d, tsd, 1e-10,
-                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
-                                                nullptr, a)[0](0);
+  var yT10 = stan::math::ode_bdf_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
   check_y0(y0);
   check_a(a);
 
-  var yT11 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT11 = stan::math::ode_bdf_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
   check_y0(y0);
   check_ts(ts);
 
-  var yT12 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0d, ts, 1e-10,
-                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
-                                                nullptr, a)[0](0);
+  var yT12 = stan::math::ode_bdf_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -790,17 +539,16 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_sens_error_test) {
   check_ts(ts);
   check_a(a);
 
-  var yT13 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT13 = stan::math::ode_bdf_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
   check_y0(y0);
   check_t0(t0);
 
-  var yT14 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0, tsd, 1e-10,
-                                                1e-10, 1e-6, {1e-6, 1e-6}, 1e6,
-                                                nullptr, a)[0](0);
+  var yT14 = stan::math::ode_bdf_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -808,8 +556,8 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_sens_error_test) {
   check_t0(t0);
   check_a(a);
 
-  var yT15 = stan::math::ode_bdf_tol_sens_error(
-      ayt(), y0, t0, ts, 1e-10, 1e-10, 1e-6, {1e-6}, 1e6, nullptr, ad)[0](0);
+  var yT15 = stan::math::ode_bdf_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -817,9 +565,8 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_sens_error_test) {
   check_t0(t0);
   check_ts(ts);
 
-  var yT16 = stan::math::ode_bdf_tol_sens_error(ayt(), y0, t0, ts, 1e-10, 1e-10,
-                                                1e-6, {1e-6, 1e-6}, 1e6,
-                                                nullptr, a)[0](0);
+  var yT16 = stan::math::ode_bdf_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
@@ -827,19 +574,4 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_sens_error_test) {
   check_t0(t0);
   check_ts(ts);
   check_a(a);
-
-  EXPECT_THROW(
-      stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                         1e-6, {1e-6, 1e-6}, 1e6, nullptr, a),
-      std::invalid_argument);
-
-  EXPECT_THROW(
-      stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                         -1e-6, {1e-6}, 1e6, nullptr, a),
-      std::domain_error);
-
-  EXPECT_THROW(
-      stan::math::ode_bdf_tol_sens_error(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
-                                         -1e-6, {-1e-6}, 1e6, nullptr, a),
-      std::domain_error);
 }
diff --git a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
index 4c06a75fe77..4a2ac8172fb 100644
--- a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
@@ -61,8 +61,8 @@ TEST(StanMathOde_ode_rk45, int_t0) {
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a);
 
-  EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
-  EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
+  EXPECT_NEAR(output[0][0], 0.4165982112, 1e-5);
+  EXPECT_NEAR(output[1][0], 0.66457668563, 1e-5);
 }
 
 TEST(StanMathOde_ode_rk45, int_ts) {
@@ -77,8 +77,8 @@ TEST(StanMathOde_ode_rk45, int_ts) {
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a);
 
-  EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
-  EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
+  EXPECT_NEAR(output[0][0], 0.6649966577, 1e-5);
+  EXPECT_NEAR(output[1][0], 0.09408000537, 1e-5);
 }
 
 TEST(StanMathOde_ode_rk45, t0) {
@@ -95,15 +95,15 @@ TEST(StanMathOde_ode_rk45, t0) {
 
   output[0][0].grad();
 
-  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+  EXPECT_NEAR(output[0][0].val(), 0.4165982112, 1e-5);
+  EXPECT_NEAR(t0.adj(), -1.0, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[1][0].grad();
 
-  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(t0.adj(), -1.0);
+  EXPECT_NEAR(output[1][0].val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(t0.adj(), -1.0, 1e-5);
 }
 
 TEST(StanMathOde_ode_rk45, ts) {
@@ -120,15 +120,15 @@ TEST(StanMathOde_ode_rk45, ts) {
 
   output[0][0].grad();
 
-  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+  EXPECT_NEAR(output[0][0].val(), 0.4165982112, 1e-5);
+  EXPECT_NEAR(ts[0].adj(), 0.78070695113, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[1][0].grad();
 
-  EXPECT_FLOAT_EQ(output[1][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(ts[1].adj(), -0.0791208888);
+  EXPECT_NEAR(output[1][0].val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(ts[1].adj(), -0.0791208888, 1e-5);
 }
 
 TEST(StanMathOde_ode_rk45, ts_repeat) {
@@ -145,29 +145,29 @@ TEST(StanMathOde_ode_rk45, ts_repeat) {
 
   output[0][0].grad();
 
-  EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(ts[0].adj(), 0.78070695113);
+  EXPECT_NEAR(output[0][0].val(), 0.4165982112, 1e-5);
+  EXPECT_NEAR(ts[0].adj(), 0.78070695113, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[1][0].grad();
 
-  EXPECT_FLOAT_EQ(output[1][0].val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(ts[1].adj(), 0.78070695113);
+  EXPECT_NEAR(output[1][0].val(), 0.4165982112, 1e-5);
+  EXPECT_NEAR(ts[1].adj(), 0.78070695113, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[2][0].grad();
 
-  EXPECT_FLOAT_EQ(output[2][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(ts[2].adj(), -0.0791208888);
+  EXPECT_NEAR(output[2][0].val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(ts[2].adj(), -0.0791208888, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[3][0].grad();
 
-  EXPECT_FLOAT_EQ(output[3][0].val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(ts[3].adj(), -0.0791208888);
+  EXPECT_NEAR(output[3][0].val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(ts[3].adj(), -0.0791208888, 1e-5);
 }
 
 TEST(StanMathOde_ode_rk45, scalar_arg) {
@@ -183,8 +183,8 @@ TEST(StanMathOde_ode_rk45, scalar_arg) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a.adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_rk45, scalar_arg_multi_time) {
@@ -201,15 +201,15 @@ TEST(StanMathOde_ode_rk45, scalar_arg_multi_time) {
 
   output[0](0).grad();
 
-  EXPECT_FLOAT_EQ(output[0](0).val(), 0.4165982112);
-  EXPECT_FLOAT_EQ(a.adj(), -0.04352005542);
+  EXPECT_NEAR(output[0](0).val(), 0.4165982112, 1e-5);
+  EXPECT_NEAR(a.adj(), -0.04352005542, 1e-5);
 
   stan::math::set_zero_all_adjoints();
 
   output[1](0).grad();
 
-  EXPECT_FLOAT_EQ(output[1](0).val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a.adj(), -0.50107310888);
+  EXPECT_NEAR(output[1](0).val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a.adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_rk45, std_vector_arg) {
@@ -225,8 +225,8 @@ TEST(StanMathOde_ode_rk45, std_vector_arg) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a[0].adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a[0].adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_rk45, vector_arg) {
@@ -243,8 +243,8 @@ TEST(StanMathOde_ode_rk45, vector_arg) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a(0).adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_rk45, row_vector_arg) {
@@ -261,8 +261,8 @@ TEST(StanMathOde_ode_rk45, row_vector_arg) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a(0).adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a(0).adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_rk45, matrix_arg) {
@@ -279,8 +279,8 @@ TEST(StanMathOde_ode_rk45, matrix_arg) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a(0, 0).adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a(0, 0).adj(), -0.50107310888, 1e-5);
 }
 
 TEST(StanMathOde_ode_rk45, scalar_std_vector_args) {
@@ -298,9 +298,92 @@ TEST(StanMathOde_ode_rk45, scalar_std_vector_args) {
 
   output.grad();
 
-  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
-  EXPECT_FLOAT_EQ(a0.adj(), -0.50107310888);
-  EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a0.adj(), -0.50107310888, 1e-5);
+  EXPECT_NEAR(a1[0].adj(), -0.50107310888, 1e-5);
+}
+
+TEST(StanMathOde_ode_rk45, std_vector_std_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 1.5;
+  std::vector<var> a1(1, a0);
+  std::vector<std::vector<var>> a2(1, a1);
+
+  var output
+      = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+
+  output.grad();
+
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a2[0][0].adj(), -0.50107310888, 1e-5);
+}
+
+TEST(StanMathOde_ode_rk45, std_vector_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 1.5;
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a1(1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> a2(1, a1);
+
+  var output
+      = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+
+  output.grad();
+
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a2[0](0).adj(), -0.50107310888, 1e-5);
+}
+
+TEST(StanMathOde_ode_rk45, std_vector_row_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 1.5;
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a1(1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> a2(1, a1);
+
+  var output
+      = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+
+  output.grad();
+
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a2[0](0).adj(), -0.50107310888, 1e-5);
+}
+
+TEST(StanMathOde_ode_rk45, std_vector_matrix_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 1.5;
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a1(1, 1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> a2(1, a1);
+
+  var output
+      = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+
+  output.grad();
+
+  EXPECT_NEAR(output.val(), 0.66457668563, 1e-5);
+  EXPECT_NEAR(a2[0](0).adj(), -0.50107310888, 1e-5);
 }
 
 struct ayt {
@@ -324,31 +407,31 @@ TEST(StanMathOde_ode_rk45, arg_combos_test) {
   Eigen::VectorXd y0d = stan::math::value_of(y0);
 
   auto check_yT = [&](auto yT) {
-    EXPECT_FLOAT_EQ(stan::math::value_of(yT),
-                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+    EXPECT_NEAR(stan::math::value_of(yT),
+                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   auto check_t0 = [&](var t0) {
-    EXPECT_FLOAT_EQ(
+    EXPECT_NEAR(
         t0.adj(),
-        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   auto check_a = [&](var a) {
-    EXPECT_FLOAT_EQ(a.adj(),
+    EXPECT_NEAR(a.adj(),
                     -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
-                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   auto check_ts = [&](std::vector<var> ts) {
-    EXPECT_FLOAT_EQ(
+    EXPECT_NEAR(
         ts[0].adj(),
-        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
-    EXPECT_FLOAT_EQ(y0(0).adj(),
-                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
+    EXPECT_NEAR(y0(0).adj(),
+                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   double yT1 = stan::math::ode_rk45(ayt(), y0d, t0d, tsd, nullptr, ad)[0](0);
diff --git a/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
index 69c313af191..8ce515ed0f8 100644
--- a/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
@@ -313,6 +313,93 @@ TEST(StanMathOde_ode_rk45_tol, scalar_std_vector_args) {
   EXPECT_FLOAT_EQ(a1[0].adj(), -0.50107310888);
 }
 
+TEST(StanMathOde_ode_rk45_tol, std_vector_std_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 1.5;
+  std::vector<var> a1(1, a0);
+  std::vector<std::vector<var>> a2(1, a1);
+
+  var output
+    = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+			       nullptr, a2)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a2[0][0].adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, std_vector_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 1.5;
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a1(1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> a2(1, a1);
+
+  var output
+    = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+			       nullptr, a2)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a2[0](0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, std_vector_row_vector_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 1.5;
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a1(1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> a2(1, a1);
+
+  var output
+    = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+			       nullptr, a2)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a2[0](0).adj(), -0.50107310888);
+}
+
+TEST(StanMathOde_ode_rk45_tol, std_vector_matrix_args) {
+  using stan::math::var;
+
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0.0;
+  std::vector<double> ts = {1.1};
+
+  var a0 = 1.5;
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a1(1, 1);
+  a1 << a0;
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> a2(1, a1);
+
+  var output
+    = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+			       nullptr, a2)[0][0];
+
+  output.grad();
+
+  EXPECT_FLOAT_EQ(output.val(), 0.66457668563);
+  EXPECT_FLOAT_EQ(a2[0](0).adj(), -0.50107310888);
+}
+
 struct ayt {
   template <typename T0, typename T1, typename T2>
   inline Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1>

From 7e411bc798e125a2ef9a7546051e31c91153d0aa Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Thu, 2 Jul 2020 13:21:50 -0400
Subject: [PATCH 151/189] Updated value_of implementation to work with holder
 again. Added tests for containers of containers (design-doc #19)

---
 stan/math/prim/fun/value_of.hpp           | 13 +++--
 test/unit/math/prim/fun/value_of_test.cpp | 43 ++++++++++++++++
 test/unit/math/rev/fun/value_of_test.cpp  | 62 +++++++++++++++++++++++
 3 files changed, 111 insertions(+), 7 deletions(-)

diff --git a/stan/math/prim/fun/value_of.hpp b/stan/math/prim/fun/value_of.hpp
index cb8acecd56b..29bff17ca67 100644
--- a/stan/math/prim/fun/value_of.hpp
+++ b/stan/math/prim/fun/value_of.hpp
@@ -18,7 +18,7 @@ namespace math {
  * @return Forwarded input argument
  **/
 template <typename T,
-	  require_arithmetic_t<stan::return_type_t<T>>* = nullptr>
+	  require_st_arithmetic<T>* = nullptr>
 inline decltype(auto) value_of(T&& x) {
   return std::forward<decltype(x)>(x);
 }
@@ -32,9 +32,9 @@ inline decltype(auto) value_of(T&& x) {
  * @return std::vector of values
  **/
 template <typename T,
-	  require_not_arithmetic_t<stan::return_type_t<T>>* = nullptr>
+	  require_not_st_arithmetic<T>* = nullptr>
 inline auto value_of(const std::vector<T>& x) {
-  std::vector<std::decay_t<decltype(value_of(std::declval<T>()))>> out;
+  std::vector<plain_type_t<decltype(value_of(std::declval<T>()))>> out;
   out.reserve(x.size());
   for (size_t n = 0; n < x.size(); ++n)
     out.emplace_back(value_of(x[n]));
@@ -52,14 +52,13 @@ inline auto value_of(const std::vector<T>& x) {
  **/
 template <typename EigMat,
 	  require_eigen_t<EigMat>* = nullptr,
-	  require_not_arithmetic_t<stan::return_type_t<EigMat>>* = nullptr>
+	  require_not_st_arithmetic<EigMat>* = nullptr>
 inline auto value_of(EigMat&& M) {
-  /*return make_holder(
+  return make_holder(
       [](auto& a) {
         return a.unaryExpr([](const auto& scal) { return value_of(scal); });
       },
-      std::forward<EigMat>(M));*/
-  return M.unaryExpr([](const auto& scal) { return value_of(scal); }).eval();
+      std::forward<EigMat>(M));
 }
 
 }  // namespace math
diff --git a/test/unit/math/prim/fun/value_of_test.cpp b/test/unit/math/prim/fun/value_of_test.cpp
index ea90da3fdda..33ad57e2706 100644
--- a/test/unit/math/prim/fun/value_of_test.cpp
+++ b/test/unit/math/prim/fun/value_of_test.cpp
@@ -84,6 +84,49 @@ TEST(MathFunctions, value_of_vector_of_vectors) {
 	       std::vector<std::vector<double>>&>::value));
   EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(vb)),
 	       const std::vector<std::vector<double>>&>::value));
+
+  auto vva = stan::math::value_of(va);
+  auto vvb = stan::math::value_of(va);
+
+  for(size_t i = 0; i < va.size(); ++i) {
+    for(size_t j = 0; j < va[i].size(); ++j) {
+      EXPECT_FLOAT_EQ(vva[i][j], a[j]);
+    }
+  }
+
+  for(size_t i = 0; i < vb.size(); ++i) {
+    for(size_t j = 0; j < vb[i].size(); ++j) {
+      EXPECT_FLOAT_EQ(vvb[i][j], b[j]);
+    }
+  }
+}
+
+TEST(MathFunctions, value_of_vector_of_eigen) {
+  Eigen::VectorXd a = Eigen::VectorXd::Random(5);
+  Eigen::RowVectorXd b = Eigen::RowVectorXd::Random(5);
+  Eigen::MatrixXd c = Eigen::MatrixXd::Random(5, 5);
+  std::vector<Eigen::VectorXd> va(5, a);
+  std::vector<Eigen::RowVectorXd> vb(5, b);
+  std::vector<Eigen::MatrixXd> vc(5, c);
+  EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(va)),
+	       std::vector<Eigen::VectorXd>&>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(vb)),
+	       std::vector<Eigen::RowVectorXd>&>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(vc)),
+	       std::vector<Eigen::MatrixXd>&>::value));
+
+  auto vva = stan::math::value_of(va);
+  auto vvb = stan::math::value_of(vb);
+  auto vvc = stan::math::value_of(vc);
+
+  for(size_t i = 0; i < vva.size(); ++i)
+    EXPECT_MATRIX_FLOAT_EQ(vva[i], a);
+
+  for(size_t i = 0; i < vvb.size(); ++i)
+    EXPECT_MATRIX_FLOAT_EQ(vvb[i], b);
+
+  for(size_t i = 0; i < vvc.size(); ++i)
+    EXPECT_MATRIX_FLOAT_EQ(vvc[i], c);
 }
 
 TEST(MathMatrixPrimMat, value_of_expression) {
diff --git a/test/unit/math/rev/fun/value_of_test.cpp b/test/unit/math/rev/fun/value_of_test.cpp
index 26da36278c6..3178ab1fc24 100644
--- a/test/unit/math/rev/fun/value_of_test.cpp
+++ b/test/unit/math/rev/fun/value_of_test.cpp
@@ -87,6 +87,68 @@ TEST(AgradMatrix, value_of) {
     }
 }
 
+TEST(AgradMatrix, value_of_vector_of_vectors) {
+  using stan::math::var;
+  std::vector<var> a(5, 0);
+  const std::vector<var> b(5, 0);
+  std::vector<std::vector<var>> va(5, a);
+  const std::vector<std::vector<var>> vb(5, b);
+  EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(va)),
+	       std::vector<std::vector<double>>>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(vb)),
+	       std::vector<std::vector<double>>>::value));
+
+  auto vva = stan::math::value_of(va);
+  auto vvb = stan::math::value_of(va);
+
+  for(size_t i = 0; i < va.size(); ++i) {
+    for(size_t j = 0; j < va[i].size(); ++j) {
+      EXPECT_FLOAT_EQ(vva[i][j], a[j].val());
+    }
+  }
+
+  for(size_t i = 0; i < vb.size(); ++i) {
+    for(size_t j = 0; j < vb[i].size(); ++j) {
+      EXPECT_FLOAT_EQ(vvb[i][j], b[j].val());
+    }
+  }
+}
+
+TEST(MathFunctions, value_of_vector_of_eigen) {
+  using stan::math::var;
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a =
+    Eigen::VectorXd::Random(5).template cast<var>();
+  Eigen::Matrix<var, 1, Eigen::Dynamic> b =
+    Eigen::RowVectorXd::Random(5).template cast<var>();
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> c =
+    Eigen::MatrixXd::Random(5, 5).template cast<var>();
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> va(5, a);
+  std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> vb(5, b);
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> vc(5, c);
+  EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(va)),
+	       std::vector<Eigen::VectorXd>>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(vb)),
+	       std::vector<Eigen::RowVectorXd>>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(vc)),
+	       std::vector<Eigen::MatrixXd>>::value));
+
+  auto vva = stan::math::value_of(va);
+  auto vvb = stan::math::value_of(vb);
+  auto vvc = stan::math::value_of(vc);
+
+  for(size_t i = 0; i < vva.size(); ++i)
+    for(size_t j = 0; j < vva[i].size(); ++j)
+      EXPECT_FLOAT_EQ(vva[i](j), a(j).val());
+
+  for(size_t i = 0; i < vvb.size(); ++i)
+    for(size_t j = 0; j < vva[i].size(); ++j)
+      EXPECT_FLOAT_EQ(vvb[i](j), b(j).val());
+
+  for(size_t i = 0; i < vvc.size(); ++i)
+    for(size_t j = 0; j < vva[i].size(); ++j)
+      EXPECT_FLOAT_EQ(vvc[i](j), c(j).val());
+}
+
 TEST(AgradMatrix, value_of_expression) {
   using Eigen::Matrix;
   using Eigen::MatrixXd;

From 52c85a4067e683d51d677ed837abcf41c476438d Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Thu, 2 Jul 2020 19:48:35 -0400
Subject: [PATCH 152/189] Added eigen version of harm_osc_ode_fun and reverse
 mode tests for coupled_ode_system (design-doc #19)

---
 .../math/prim/functor/harmonic_oscillator.hpp |  18 +
 .../rev/functor/coupled_ode_system_test.cpp   | 407 +++++++++++++++---
 2 files changed, 364 insertions(+), 61 deletions(-)

diff --git a/test/unit/math/prim/functor/harmonic_oscillator.hpp b/test/unit/math/prim/functor/harmonic_oscillator.hpp
index a49d17686b1..7a236786ec6 100644
--- a/test/unit/math/prim/functor/harmonic_oscillator.hpp
+++ b/test/unit/math/prim/functor/harmonic_oscillator.hpp
@@ -28,6 +28,24 @@ struct harm_osc_ode_fun {
   }
 };
 
+struct harm_osc_ode_fun_eigen {
+  template <typename T0, typename T1, typename T2>
+  inline auto
+  operator()(const T0& t_in, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y_in, std::ostream* msgs,
+             const std::vector<T2>& theta, const std::vector<double>& x,
+             const std::vector<int>& x_int) const {
+    if (y_in.size() != 2)
+      throw std::domain_error(
+          "this function was called with inconsistent state");
+
+    Eigen::Matrix<stan::return_type_t<T1, T2>, Eigen::Dynamic, 1> res(2);
+    res(0) = y_in(1);
+    res(1) = -y_in(0) - theta[0] * y_in(1);
+
+    return res;
+  }
+};
+
 struct harm_osc_ode_data_fun {
   template <typename T0, typename T1, typename T2>
   inline std::vector<stan::return_type_t<T1, T2>>
diff --git a/test/unit/math/rev/functor/coupled_ode_system_test.cpp b/test/unit/math/rev/functor/coupled_ode_system_test.cpp
index a097aee047e..be4739c1b21 100644
--- a/test/unit/math/rev/functor/coupled_ode_system_test.cpp
+++ b/test/unit/math/rev/functor/coupled_ode_system_test.cpp
@@ -21,11 +21,11 @@ TEST_F(StanAgradRevOde, coupled_ode_system_dv) {
   // Run nested autodiff in this scope
   stan::math::nested_rev_autodiff nested;
 
-  harm_osc_ode_fun harm_osc;
+  harm_osc_ode_fun_eigen harm_osc;
 
   std::vector<stan::math::var> theta;
   std::vector<double> z0;
-  std::vector<double> y0;
+  Eigen::VectorXd y0(2);
   double t0;
   const size_t z_size = 4;
   std::vector<double> dz_dt(z_size, 0);
@@ -34,8 +34,7 @@ TEST_F(StanAgradRevOde, coupled_ode_system_dv) {
   t0 = 0;
 
   theta.push_back(gamma);
-  y0.push_back(1.0);
-  y0.push_back(0.5);
+  y0 << 1.0, 0.5;
 
   z0.push_back(1.0);
   z0.push_back(0.5);
@@ -44,8 +43,10 @@ TEST_F(StanAgradRevOde, coupled_ode_system_dv) {
 
   std::size_t stack_size = stan::math::nested_size();
 
-  coupled_ode_system<harm_osc_ode_fun, double, stan::math::var> system(
-      harm_osc, y0, theta, x, x_int, &msgs);
+  coupled_ode_system<decltype(harm_osc), double,
+		     std::vector<stan::math::var>,
+		     std::vector<double>, std::vector<int>> system(
+      harm_osc, y0, &msgs, theta, x, x_int);
 
   EXPECT_EQ(stack_size, stan::math::nested_size())
       << "expecting no new things on the stack";
@@ -57,6 +58,7 @@ TEST_F(StanAgradRevOde, coupled_ode_system_dv) {
   EXPECT_FLOAT_EQ(2, dz_dt[2]);
   EXPECT_FLOAT_EQ(-1.8, dz_dt[3]);
 }
+
 TEST_F(StanAgradRevOde, initial_state_dv) {
   using stan::math::coupled_ode_system;
   using stan::math::var;
@@ -66,7 +68,7 @@ TEST_F(StanAgradRevOde, initial_state_dv) {
   const size_t M = 4;
   const size_t z_size = N + N * M;
 
-  std::vector<double> y0_d(N, 0.0);
+  Eigen::VectorXd y0_d = Eigen::VectorXd::Zero(N);
   std::vector<var> theta_v(M, 0.0);
 
   for (size_t n = 0; n < N; n++)
@@ -74,8 +76,10 @@ TEST_F(StanAgradRevOde, initial_state_dv) {
   for (size_t m = 0; m < M; m++)
     theta_v[m] = 10 * (m + 1);
 
-  coupled_ode_system<mock_ode_functor, double, var> coupled_system_dv(
-      base_ode, y0_d, theta_v, x, x_int, &msgs);
+  coupled_ode_system<decltype(base_ode), double,
+		     std::vector<stan::math::var>,
+		     std::vector<double>, std::vector<int>> coupled_system_dv(
+      base_ode, y0_d, &msgs, theta_v, x, x_int);
 
   std::vector<double> state = coupled_system_dv.initial_state();
   for (size_t n = 0; n < N; n++)
@@ -85,6 +89,7 @@ TEST_F(StanAgradRevOde, initial_state_dv) {
   for (size_t n = N; n < state.size(); n++)
     EXPECT_FLOAT_EQ(0.0, state[n]);
 }
+
 TEST_F(StanAgradRevOde, size_dv) {
   using stan::math::coupled_ode_system;
   using stan::math::var;
@@ -94,11 +99,13 @@ TEST_F(StanAgradRevOde, size_dv) {
   const size_t M = 4;
   const size_t z_size = N + N * M;
 
-  std::vector<double> y0_d(N, 0.0);
+  Eigen::VectorXd y0_d = Eigen::VectorXd::Zero(N);
   std::vector<var> theta_v(M, 0.0);
 
-  coupled_ode_system<mock_ode_functor, double, var> coupled_system_dv(
-      base_ode, y0_d, theta_v, x, x_int, &msgs);
+  coupled_ode_system<decltype(base_ode), double,
+		     std::vector<stan::math::var>,
+		     std::vector<double>, std::vector<int>> coupled_system_dv(
+      base_ode, y0_d, &msgs, theta_v, x, x_int);
 
   EXPECT_EQ(z_size, coupled_system_dv.size());
 }
@@ -112,11 +119,13 @@ TEST_F(StanAgradRevOde, memory_recovery_dv) {
   const size_t M = 4;
   const size_t z_size = N + N * M;
 
-  std::vector<double> y0_d(N, 0.0);
+  Eigen::VectorXd y0_d = Eigen::VectorXd::Zero(N);
   std::vector<var> theta_v(M, 0.0);
 
-  coupled_ode_system<mock_ode_functor, double, var> coupled_system_dv(
-      base_ode, y0_d, theta_v, x, x_int, &msgs);
+  coupled_ode_system<decltype(base_ode), double,
+		     std::vector<stan::math::var>,
+		     std::vector<double>, std::vector<int>> coupled_system_dv(
+      base_ode, y0_d, &msgs, theta_v, x, x_int);
 
   std::vector<double> z(z_size, 0);
   std::vector<double> dz_dt(z_size, 0);
@@ -142,11 +151,13 @@ TEST_F(StanAgradRevOde, memory_recovery_exception_dv) {
     SCOPED_TRACE(scoped_message.str());
     mock_throwing_ode_functor<std::logic_error> throwing_ode(message, 1);
 
-    std::vector<double> y0_d(N, 0.0);
+    Eigen::VectorXd y0_d = Eigen::VectorXd::Zero(N);
     std::vector<var> theta_v(M, 0.0);
 
-    coupled_ode_system<mock_throwing_ode_functor<std::logic_error>, double, var>
-        coupled_system_dv(throwing_ode, y0_d, theta_v, x, x_int, &msgs);
+    coupled_ode_system<decltype(throwing_ode), double,
+		       std::vector<stan::math::var>,
+		       std::vector<double>, std::vector<int>>
+      coupled_system_dv(throwing_ode, y0_d, &msgs, theta_v, x, x_int);
 
     std::vector<double> z(z_size, 0);
     std::vector<double> dz_dt(z_size, 0);
@@ -166,11 +177,11 @@ TEST_F(StanAgradRevOde, coupled_ode_system_vd) {
   // Run nested autodiff in this scope
   stan::math::nested_rev_autodiff nested;
 
-  harm_osc_ode_fun harm_osc;
+  harm_osc_ode_fun_eigen harm_osc;
 
   std::vector<double> theta;
   std::vector<double> z0;
-  std::vector<stan::math::var> y0_var;
+  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_var(2);
   std::vector<double> y0_adj;
   double t0;
   const size_t N = 2;
@@ -189,13 +200,14 @@ TEST_F(StanAgradRevOde, coupled_ode_system_vd) {
   z0.push_back(0.0);
   z0.push_back(1.0);
 
-  y0_var.push_back(1.0);
-  y0_var.push_back(0.5);
+  y0_var << 1.0, 0.5;
 
   std::size_t stack_size = stan::math::nested_size();
 
-  coupled_ode_system<harm_osc_ode_fun, stan::math::var, double> system(
-      harm_osc, y0_var, theta, x, x_int, &msgs);
+  coupled_ode_system<decltype(harm_osc), stan::math::var,
+		       std::vector<double>,
+		       std::vector<double>, std::vector<int>>
+    system(harm_osc, y0_var, &msgs, theta, x, x_int);
 
   EXPECT_EQ(stack_size, stan::math::nested_size())
       << "expecting no new things on the stack";
@@ -218,7 +230,8 @@ TEST_F(StanAgradRevOde, initial_state_vd) {
   const size_t N = 3;
   const size_t M = 4;
 
-  std::vector<var> y0_v(N, 0.0);
+  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v =
+    Eigen::VectorXd::Zero(N).template cast<var>();
   std::vector<double> theta_d(M, 0.0);
 
   for (size_t n = 0; n < N; n++)
@@ -226,8 +239,10 @@ TEST_F(StanAgradRevOde, initial_state_vd) {
   for (size_t m = 0; m < M; m++)
     theta_d[m] = 10 * (m + 1);
 
-  coupled_ode_system<mock_ode_functor, var, double> coupled_system_vd(
-      base_ode, y0_v, theta_d, x, x_int, &msgs);
+  coupled_ode_system<decltype(base_ode), stan::math::var,
+		       std::vector<double>,
+		       std::vector<double>, std::vector<int>>
+    coupled_system_vd(base_ode, y0_v, &msgs, theta_d, x, x_int);
 
   std::vector<double> state;
 
@@ -238,6 +253,7 @@ TEST_F(StanAgradRevOde, initial_state_vd) {
     for (size_t j = 0; j < N; j++)
       EXPECT_FLOAT_EQ(i == j ? 1.0 : 0.0, state[N + i + j * N]);
 }
+
 TEST_F(StanAgradRevOde, size_vd) {
   using stan::math::coupled_ode_system;
   using stan::math::var;
@@ -247,11 +263,14 @@ TEST_F(StanAgradRevOde, size_vd) {
   const size_t M = 4;
   const size_t z_size = N + N * N;
 
-  std::vector<var> y0_v(N, 0.0);
+  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v =
+    Eigen::VectorXd::Zero(N).template cast<var>();
   std::vector<double> theta_d(M, 0.0);
 
-  coupled_ode_system<mock_ode_functor, var, double> coupled_system_vd(
-      base_ode, y0_v, theta_d, x, x_int, &msgs);
+  coupled_ode_system<decltype(base_ode), stan::math::var,
+		       std::vector<double>,
+		       std::vector<double>, std::vector<int>>
+    coupled_system_vd(base_ode, y0_v, &msgs, theta_d, x, x_int);
 
   EXPECT_EQ(z_size, coupled_system_vd.size());
 }
@@ -265,11 +284,14 @@ TEST_F(StanAgradRevOde, memory_recovery_vd) {
   const size_t M = 4;
   const size_t z_size = N + N * N;
 
-  std::vector<var> y0_v(N, 0.0);
+  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v =
+    Eigen::VectorXd::Zero(N).template cast<var>();
   std::vector<double> theta_d(M, 0.0);
 
-  coupled_ode_system<mock_ode_functor, var, double> coupled_system_vd(
-      base_ode, y0_v, theta_d, x, x_int, &msgs);
+  coupled_ode_system<decltype(base_ode), stan::math::var,
+		     std::vector<double>,
+		     std::vector<double>, std::vector<int>>
+    coupled_system_vd(base_ode, y0_v, &msgs, theta_d, x, x_int);
 
   std::vector<double> z(z_size, 0);
   std::vector<double> dz_dt(z_size, 0);
@@ -295,11 +317,14 @@ TEST_F(StanAgradRevOde, memory_recovery_exception_vd) {
     SCOPED_TRACE(scoped_message.str());
     mock_throwing_ode_functor<std::logic_error> throwing_ode(message, 1);
 
-    std::vector<var> y0_v(N, 0.0);
+  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v =
+    Eigen::VectorXd::Zero(N).template cast<var>();
     std::vector<double> theta_d(M, 0.0);
 
-    coupled_ode_system<mock_throwing_ode_functor<std::logic_error>, var, double>
-        coupled_system_vd(throwing_ode, y0_v, theta_d, x, x_int, &msgs);
+    coupled_ode_system<decltype(throwing_ode), stan::math::var,
+		       std::vector<double>,
+		       std::vector<double>, std::vector<int>>
+      coupled_system_vd(throwing_ode, y0_v, &msgs, theta_d, x, x_int);
 
     std::vector<double> z(z_size, 0);
     std::vector<double> dz_dt(z_size, 0);
@@ -323,19 +348,20 @@ TEST_F(StanAgradRevOde, coupled_ode_system_vv) {
   const size_t M = 1;
   const size_t z_size = N + N * N + N * M;
 
-  std::vector<stan::math::var> y0_var;
-  y0_var.push_back(1.0);
-  y0_var.push_back(0.5);
+  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_var(2);
+  y0_var << 1.0, 0.5;
 
-  std::vector<stan::math::var> theta_var;
-  theta_var.push_back(0.15);
+  std::vector<stan::math::var> theta_var(1);
+  theta_var[0] = 0.15;
 
-  harm_osc_ode_fun harm_osc;
+  harm_osc_ode_fun_eigen harm_osc;
 
   std::size_t stack_size = stan::math::nested_size();
 
-  coupled_ode_system<harm_osc_ode_fun, stan::math::var, stan::math::var> system(
-      harm_osc, y0_var, theta_var, x, x_int, &msgs);
+  coupled_ode_system<decltype(harm_osc), stan::math::var,
+		     std::vector<stan::math::var>,
+		     std::vector<double>, std::vector<int>>
+    system(harm_osc, y0_var, &msgs, theta_var, x, x_int);
 
   EXPECT_EQ(stack_size, stan::math::nested_size())
       << "expecting no new things on the stack";
@@ -352,15 +378,14 @@ TEST_F(StanAgradRevOde, coupled_ode_system_vv) {
   std::vector<double> dz_dt(z_size);
   system(z0, dz_dt, t0);
 
-  std::vector<double> y0_double(2);
-  y0_double[0] = 1.0;
-  y0_double[1] = 0.5;
+  Eigen::VectorXd y0_double(2);
+  y0_double << 1.0, 0.5;
 
   std::vector<double> theta_double(1);
   theta_double[0] = 0.15;
 
-  std::vector<double> dy_dt_base
-      = harm_osc(0.0, y0_double, theta_double, x, x_int, &msgs);
+  Eigen::VectorXd dy_dt_base
+      = harm_osc(0.0, y0_double, &msgs, theta_double, x, x_int);
 
   EXPECT_FLOAT_EQ(dy_dt_base[0], dz_dt[0]);
   EXPECT_FLOAT_EQ(dy_dt_base[1], dz_dt[1]);
@@ -371,6 +396,7 @@ TEST_F(StanAgradRevOde, coupled_ode_system_vv) {
   EXPECT_FLOAT_EQ(0, dz_dt[6]);
   EXPECT_FLOAT_EQ(-0.5, dz_dt[7]);
 }
+
 TEST_F(StanAgradRevOde, initial_state_vv) {
   using stan::math::coupled_ode_system;
   using stan::math::var;
@@ -379,7 +405,8 @@ TEST_F(StanAgradRevOde, initial_state_vv) {
   const size_t N = 3;
   const size_t M = 4;
 
-  std::vector<var> y0_v(N, 0.0);
+  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v =
+    Eigen::VectorXd::Zero(N).template cast<var>();
   std::vector<var> theta_v(M, 0.0);
 
   for (size_t n = 0; n < N; n++)
@@ -387,8 +414,10 @@ TEST_F(StanAgradRevOde, initial_state_vv) {
   for (size_t m = 0; m < M; m++)
     theta_v[m] = 10 * (m + 1);
 
-  coupled_ode_system<mock_ode_functor, var, var> coupled_system_vv(
-      base_ode, y0_v, theta_v, x, x_int, &msgs);
+  coupled_ode_system<decltype(base_ode), stan::math::var,
+		     std::vector<stan::math::var>,
+		     std::vector<double>, std::vector<int>>
+    coupled_system_vv(base_ode, y0_v, &msgs, theta_v, x, x_int);
 
   std::vector<double> state = coupled_system_vv.initial_state();
   for (size_t n = 0; n < N; n++)
@@ -399,6 +428,7 @@ TEST_F(StanAgradRevOde, initial_state_vv) {
   for (size_t n = N + N * N; n < N + N * N + N * M; n++)
     EXPECT_FLOAT_EQ(0.0, state[n]);
 }
+
 TEST_F(StanAgradRevOde, size_vv) {
   using stan::math::coupled_ode_system;
   using stan::math::var;
@@ -408,11 +438,14 @@ TEST_F(StanAgradRevOde, size_vv) {
   const size_t M = 4;
   const size_t z_size = N + N * N + N * M;
 
-  std::vector<var> y0_v(N, 0.0);
+  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v =
+    Eigen::VectorXd::Zero(N).template cast<var>();
   std::vector<var> theta_v(M, 0.0);
 
-  coupled_ode_system<mock_ode_functor, var, var> coupled_system_vv(
-      base_ode, y0_v, theta_v, x, x_int, &msgs);
+  coupled_ode_system<decltype(base_ode), stan::math::var,
+		     std::vector<stan::math::var>,
+		     std::vector<double>, std::vector<int>>
+    coupled_system_vv(base_ode, y0_v, &msgs, theta_v, x, x_int);
 
   EXPECT_EQ(z_size, coupled_system_vv.size());
 }
@@ -426,11 +459,14 @@ TEST_F(StanAgradRevOde, memory_recovery_vv) {
   const size_t M = 4;
   const size_t z_size = N + N * N + N * M;
 
-  std::vector<var> y0_v(N, 0.0);
+  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v =
+    Eigen::VectorXd::Zero(N).template cast<var>();
   std::vector<var> theta_v(M, 0.0);
 
-  coupled_ode_system<mock_ode_functor, var, var> coupled_system_vv(
-      base_ode, y0_v, theta_v, x, x_int, &msgs);
+  coupled_ode_system<decltype(base_ode), stan::math::var,
+		     std::vector<stan::math::var>,
+		     std::vector<double>, std::vector<int>>
+    coupled_system_vv(base_ode, y0_v, &msgs, theta_v, x, x_int);
 
   std::vector<double> z(z_size, 0);
   std::vector<double> dz_dt(z_size, 0);
@@ -456,11 +492,14 @@ TEST_F(StanAgradRevOde, memory_recovery_exception_vv) {
     SCOPED_TRACE(scoped_message.str());
     mock_throwing_ode_functor<std::logic_error> throwing_ode(message, 1);
 
-    std::vector<var> y0_v(N, 0.0);
+    Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v =
+      Eigen::VectorXd::Zero(N).template cast<var>();
     std::vector<var> theta_v(M, 0.0);
 
-    coupled_ode_system<mock_throwing_ode_functor<std::logic_error>, var, var>
-        coupled_system_vv(throwing_ode, y0_v, theta_v, x, x_int, &msgs);
+    coupled_ode_system<decltype(throwing_ode), stan::math::var,
+		       std::vector<stan::math::var>,
+		       std::vector<double>, std::vector<int>>
+      coupled_system_vv(throwing_ode, y0_v, &msgs, theta_v, x, x_int);
 
     std::vector<double> z(z_size, 0);
     std::vector<double> dz_dt(z_size, 0);
@@ -471,3 +510,249 @@ TEST_F(StanAgradRevOde, memory_recovery_exception_vv) {
     EXPECT_TRUE(stan::math::empty_nested());
   }
 }
+
+template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
+T sum_(T arg) {
+  return arg;
+}
+
+template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
+auto sum_(EigMat&& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
+auto sum_(Vec&& arg) {
+  stan::scalar_type_t<Vec> sum = 0;
+  for (size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
+  }
+  return sum;
+}
+
+struct ayt {
+  template <typename T0, typename T_y, typename... T_Args>
+  inline auto operator()(const T0& t, const T_y& y, std::ostream* msgs,
+			 const T_Args&... args) const {
+    std::vector<typename stan::return_type<T_Args...>::type> vec
+        = {sum_(args)...};
+    Eigen::Matrix<stan::return_type_t<T0, T_y, T_Args...>, Eigen::Dynamic, 1> out(2);
+    out(0) = -sum_(vec) * y(0) * t;
+    out(1) = -1.7 * sum_(vec) * y(1) * t;
+    return out;
+  }
+};
+
+TEST_F(StanAgradRevOde, coupled_ode_system_var) {
+  using stan::math::coupled_ode_system;
+  using stan::math::var;
+
+  Eigen::VectorXd y0(2);
+  y0 << 0.1, 0.2;
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0v = y0.template cast<var>();
+
+  double a = 1.3;
+  var av = a;
+
+  ayt func;
+
+  coupled_ode_system<ayt, stan::math::var,
+		     decltype(av)>
+    system(func, y0v, &msgs, av);
+
+  std::vector<double> z = { y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2 };
+
+  double t0 = 0.75;
+
+  std::vector<double> dz_dt;
+  system(z, dz_dt, t0);
+
+  EXPECT_FLOAT_EQ(dz_dt[0], -0.0975);
+  EXPECT_FLOAT_EQ(dz_dt[1], -0.3315);
+  EXPECT_FLOAT_EQ(dz_dt[2], -3.12000);
+  EXPECT_FLOAT_EQ(dz_dt[3], -5.46975);
+  EXPECT_FLOAT_EQ(dz_dt[4], -4.29000);
+  EXPECT_FLOAT_EQ(dz_dt[5], -7.45875);
+  EXPECT_FLOAT_EQ(dz_dt[6], -2.1225);
+  EXPECT_FLOAT_EQ(dz_dt[7], -3.9015);
+}
+
+TEST_F(StanAgradRevOde, coupled_ode_system_std_vector) {
+  using stan::math::coupled_ode_system;
+  using stan::math::var;
+
+  Eigen::VectorXd y0(2);
+  y0 << 0.1, 0.2;
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0v = y0.template cast<var>();
+
+  std::vector<var> av = { 1.3 };
+
+  ayt func;
+
+  coupled_ode_system<ayt, stan::math::var,
+		     decltype(av)>
+    system(func, y0v, &msgs, av);
+
+  std::vector<double> z = { y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2 };
+
+  double t0 = 0.75;
+
+  std::vector<double> dz_dt;
+  system(z, dz_dt, t0);
+
+  EXPECT_FLOAT_EQ(dz_dt[0], -0.0975);
+  EXPECT_FLOAT_EQ(dz_dt[1], -0.3315);
+  EXPECT_FLOAT_EQ(dz_dt[2], -3.12000);
+  EXPECT_FLOAT_EQ(dz_dt[3], -5.46975);
+  EXPECT_FLOAT_EQ(dz_dt[4], -4.29000);
+  EXPECT_FLOAT_EQ(dz_dt[5], -7.45875);
+  EXPECT_FLOAT_EQ(dz_dt[6], -2.1225);
+  EXPECT_FLOAT_EQ(dz_dt[7], -3.9015);
+}
+
+TEST_F(StanAgradRevOde, coupled_ode_system_vector) {
+  using stan::math::coupled_ode_system;
+  using stan::math::var;
+
+  Eigen::VectorXd y0(2);
+  y0 << 0.1, 0.2;
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0v = y0.template cast<var>();
+
+  Eigen::Matrix<var, Eigen::Dynamic, 1> av(1);
+  av << 1.3 ;
+
+  ayt func;
+
+  coupled_ode_system<ayt, stan::math::var,
+		     decltype(av)>
+    system(func, y0v, &msgs, av);
+
+  std::vector<double> z = { y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2 };
+
+  double t0 = 0.75;
+
+  std::vector<double> dz_dt;
+  system(z, dz_dt, t0);
+
+  EXPECT_FLOAT_EQ(dz_dt[0], -0.0975);
+  EXPECT_FLOAT_EQ(dz_dt[1], -0.3315);
+  EXPECT_FLOAT_EQ(dz_dt[2], -3.12000);
+  EXPECT_FLOAT_EQ(dz_dt[3], -5.46975);
+  EXPECT_FLOAT_EQ(dz_dt[4], -4.29000);
+  EXPECT_FLOAT_EQ(dz_dt[5], -7.45875);
+  EXPECT_FLOAT_EQ(dz_dt[6], -2.1225);
+  EXPECT_FLOAT_EQ(dz_dt[7], -3.9015);
+}
+
+TEST_F(StanAgradRevOde, coupled_ode_system_row_vector) {
+  using stan::math::coupled_ode_system;
+  using stan::math::var;
+
+  Eigen::VectorXd y0(2);
+  y0 << 0.1, 0.2;
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0v = y0.template cast<var>();
+
+  Eigen::Matrix<var, 1, Eigen::Dynamic> av(1);
+  av << 1.3 ;
+
+  ayt func;
+
+  coupled_ode_system<ayt, stan::math::var,
+		     decltype(av)>
+    system(func, y0v, &msgs, av);
+
+  std::vector<double> z = { y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2 };
+
+  double t0 = 0.75;
+
+  std::vector<double> dz_dt;
+  system(z, dz_dt, t0);
+
+  EXPECT_FLOAT_EQ(dz_dt[0], -0.0975);
+  EXPECT_FLOAT_EQ(dz_dt[1], -0.3315);
+  EXPECT_FLOAT_EQ(dz_dt[2], -3.12000);
+  EXPECT_FLOAT_EQ(dz_dt[3], -5.46975);
+  EXPECT_FLOAT_EQ(dz_dt[4], -4.29000);
+  EXPECT_FLOAT_EQ(dz_dt[5], -7.45875);
+  EXPECT_FLOAT_EQ(dz_dt[6], -2.1225);
+  EXPECT_FLOAT_EQ(dz_dt[7], -3.9015);
+}
+
+TEST_F(StanAgradRevOde, coupled_ode_system_matrix) {
+  using stan::math::coupled_ode_system;
+  using stan::math::var;
+
+  Eigen::VectorXd y0(2);
+  y0 << 0.1, 0.2;
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0v = y0.template cast<var>();
+
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> av(1, 1);
+  av << 1.3 ;
+
+  ayt func;
+
+  coupled_ode_system<ayt, stan::math::var,
+		     decltype(av)>
+    system(func, y0v, &msgs, av);
+
+  std::vector<double> z = { y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2 };
+
+  double t0 = 0.75;
+
+  std::vector<double> dz_dt;
+  system(z, dz_dt, t0);
+
+  EXPECT_FLOAT_EQ(dz_dt[0], -0.0975);
+  EXPECT_FLOAT_EQ(dz_dt[1], -0.3315);
+  EXPECT_FLOAT_EQ(dz_dt[2], -3.12000);
+  EXPECT_FLOAT_EQ(dz_dt[3], -5.46975);
+  EXPECT_FLOAT_EQ(dz_dt[4], -4.29000);
+  EXPECT_FLOAT_EQ(dz_dt[5], -7.45875);
+  EXPECT_FLOAT_EQ(dz_dt[6], -2.1225);
+  EXPECT_FLOAT_EQ(dz_dt[7], -3.9015);
+}
+
+TEST_F(StanAgradRevOde, coupled_ode_system_extra_args) {
+  using stan::math::coupled_ode_system;
+  using stan::math::var;
+
+  Eigen::VectorXd y0(2);
+  y0 << 0.1, 0.2;
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0v = y0.template cast<var>();
+
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> av(1, 1);
+  av << -0.2;
+  int e1 = 1;
+  double e2 = 0.1;
+  std::vector<double> e3 = { 0.1 };
+  Eigen::VectorXd e4(1);
+  e4 << 0.1;
+  Eigen::VectorXd e5(1);
+  e5 << 0.1;
+  Eigen::MatrixXd e6(1, 1);
+  e6 << 0.1;
+
+  ayt func;
+
+  coupled_ode_system<ayt, stan::math::var,
+		     decltype(av),
+		     decltype(e1), decltype(e2), decltype(e3),
+		     decltype(e4), decltype(e5), decltype(e6)>
+    system(func, y0v, &msgs, av, e1, e2, e3, e4, e5, e6);
+
+  std::vector<double> z = { y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2 };
+
+  double t0 = 0.75;
+
+  std::vector<double> dz_dt;
+  system(z, dz_dt, t0);
+
+  EXPECT_FLOAT_EQ(dz_dt[0], -0.0975);
+  EXPECT_FLOAT_EQ(dz_dt[1], -0.3315);
+  EXPECT_FLOAT_EQ(dz_dt[2], -3.12000);
+  EXPECT_FLOAT_EQ(dz_dt[3], -5.46975);
+  EXPECT_FLOAT_EQ(dz_dt[4], -4.29000);
+  EXPECT_FLOAT_EQ(dz_dt[5], -7.45875);
+  EXPECT_FLOAT_EQ(dz_dt[6], -2.1225);
+  EXPECT_FLOAT_EQ(dz_dt[7], -3.9015);
+}

From 8ab9809ce61049c2b12659e1f1178ef4f5f24d09 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 3 Jul 2020 09:27:07 -0400
Subject: [PATCH 153/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 stan/math/prim/err/check_finite.hpp           |  26 +--
 stan/math/prim/fun/value_of.hpp               |  16 +-
 stan/math/rev/functor/coupled_ode_system.hpp  |   3 +-
 test/unit/math/prim/fun/value_of_test.cpp     |  24 +--
 .../math/prim/functor/harmonic_oscillator.hpp |   9 +-
 .../math/prim/functor/ode_rk45_prim_test.cpp  |  24 +--
 .../prim/functor/ode_rk45_tol_prim_test.cpp   |  24 +--
 test/unit/math/rev/fun/value_of_test.cpp      |  43 ++--
 .../rev/functor/coupled_ode_system_test.cpp   | 191 ++++++++----------
 .../math/rev/functor/ode_adams_prim_test.cpp  |  30 +--
 .../math/rev/functor/ode_adams_rev_test.cpp   |  29 ++-
 .../rev/functor/ode_adams_tol_prim_test.cpp   | 146 ++++++-------
 .../rev/functor/ode_adams_tol_rev_test.cpp    |  90 ++++-----
 .../math/rev/functor/ode_bdf_prim_test.cpp    |  24 +--
 .../math/rev/functor/ode_bdf_rev_test.cpp     |  29 ++-
 .../rev/functor/ode_bdf_tol_prim_test.cpp     | 184 ++++++++---------
 .../math/rev/functor/ode_bdf_tol_rev_test.cpp |  76 ++++---
 .../math/rev/functor/ode_rk45_rev_test.cpp    |  29 ++-
 .../rev/functor/ode_rk45_tol_rev_test.cpp     |  20 +-
 19 files changed, 492 insertions(+), 525 deletions(-)

diff --git a/stan/math/prim/err/check_finite.hpp b/stan/math/prim/err/check_finite.hpp
index 72093db9fc5..8bb7a68bb86 100644
--- a/stan/math/prim/err/check_finite.hpp
+++ b/stan/math/prim/err/check_finite.hpp
@@ -37,7 +37,7 @@ bool is_finite(const std::vector<T_y>& y) {
   }
   return all;
 }
-}
+}  // namespace internal
 
 /**
  * Check if <code>y</code> is finite.
@@ -49,8 +49,7 @@ bool is_finite(const std::vector<T_y>& y) {
  * @param y Variable to check
  * @throw <code>domain_error</code> if y is infinity, -infinity, or NaN
  */
-template <typename T_y,
-	  require_stan_scalar_t<T_y>* = nullptr>
+template <typename T_y, require_stan_scalar_t<T_y>* = nullptr>
 inline void check_finite(const char* function, const char* name, const T_y& y) {
   if (!internal::is_finite(y)) {
     throw_domain_error(function, name, y, "is ", ", but must be finite!");
@@ -67,14 +66,13 @@ inline void check_finite(const char* function, const char* name, const T_y& y) {
  * @param y std::vector to test
  * @return <code>true</code> if all values are finite
  **/
-template <typename T_y,
-	  require_stan_scalar_t<T_y>* = nullptr>
+template <typename T_y, require_stan_scalar_t<T_y>* = nullptr>
 inline void check_finite(const char* function, const char* name,
-			 const std::vector<T_y>& y) {
+                         const std::vector<T_y>& y) {
   for (size_t n = 0; n < stan::math::size(y); n++) {
     if (!internal::is_finite(stan::get(y, n))) {
       throw_domain_error_vec(function, name, y, n, "is ",
-			     ", but must be finite!");
+                             ", but must be finite!");
     }
   }
 }
@@ -93,12 +91,12 @@ inline void check_finite(const char* function, const char* name,
  **/
 template <typename T_y, int R, int C>
 inline void check_finite(const char* function, const char* name,
-			 const Eigen::Matrix<T_y, R, C>& y) {
+                         const Eigen::Matrix<T_y, R, C>& y) {
   if (!value_of(y).allFinite()) {
     for (int n = 0; n < y.size(); ++n) {
       if (!std::isfinite(value_of_rec(y(n)))) {
-	throw_domain_error_vec(function, name, y, n, "is ",
-			       ", but must be finite!");
+        throw_domain_error_vec(function, name, y, n, "is ",
+                               ", but must be finite!");
       }
     }
   }
@@ -114,14 +112,12 @@ inline void check_finite(const char* function, const char* name,
  * @param y std::vector to test
  * @return <code>true</code> if all values are finite
  **/
-template <typename T_y,
-	  require_not_stan_scalar_t<T_y>* = nullptr>
+template <typename T_y, require_not_stan_scalar_t<T_y>* = nullptr>
 inline void check_finite(const char* function, const char* name,
-			 const std::vector<T_y>& y) {
+                         const std::vector<T_y>& y) {
   for (size_t n = 0; n < stan::math::size(y); n++) {
     if (!internal::is_finite(stan::get(y, n))) {
-      throw_domain_error(function, name, "", "",
-			 "is not finite!");
+      throw_domain_error(function, name, "", "", "is not finite!");
     }
   }
 }
diff --git a/stan/math/prim/fun/value_of.hpp b/stan/math/prim/fun/value_of.hpp
index 29bff17ca67..7cf488bf7bb 100644
--- a/stan/math/prim/fun/value_of.hpp
+++ b/stan/math/prim/fun/value_of.hpp
@@ -17,8 +17,7 @@ namespace math {
  * @param[in] x Input argument
  * @return Forwarded input argument
  **/
-template <typename T,
-	  require_st_arithmetic<T>* = nullptr>
+template <typename T, require_st_arithmetic<T>* = nullptr>
 inline decltype(auto) value_of(T&& x) {
   return std::forward<decltype(x)>(x);
 }
@@ -31,8 +30,7 @@ inline decltype(auto) value_of(T&& x) {
  * @param[in] x Input std::vector
  * @return std::vector of values
  **/
-template <typename T,
-	  require_not_st_arithmetic<T>* = nullptr>
+template <typename T, require_not_st_arithmetic<T>* = nullptr>
 inline auto value_of(const std::vector<T>& x) {
   std::vector<plain_type_t<decltype(value_of(std::declval<T>()))>> out;
   out.reserve(x.size());
@@ -42,17 +40,17 @@ inline auto value_of(const std::vector<T>& x) {
 }
 
 /**
- * For Eigen matrices and expressions of non-arithmetic types, return an expression
- * that represents the Eigen::Matrix resulting from applying value_of elementwise
+ * For Eigen matrices and expressions of non-arithmetic types, return an
+ *expression that represents the Eigen::Matrix resulting from applying value_of
+ *elementwise
  *
  * @tparam EigMat type of the matrix
  *
  * @param[in] M Matrix to be converted
  * @return Matrix of values
  **/
-template <typename EigMat,
-	  require_eigen_t<EigMat>* = nullptr,
-	  require_not_st_arithmetic<EigMat>* = nullptr>
+template <typename EigMat, require_eigen_t<EigMat>* = nullptr,
+          require_not_st_arithmetic<EigMat>* = nullptr>
 inline auto value_of(EigMat&& M) {
   return make_holder(
       [](auto& a) {
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index c36fa6109fa..fb5e733fb8b 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -173,8 +173,7 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
           },
           local_args_tuple_);
 
-      apply([&](auto&&... args) { zero_adjoints(args...); },
-	    local_args_tuple_);
+      apply([&](auto&&... args) { zero_adjoints(args...); }, local_args_tuple_);
 
       // No need to zero adjoints after last sweep
       if (i < N_) {
diff --git a/test/unit/math/prim/fun/value_of_test.cpp b/test/unit/math/prim/fun/value_of_test.cpp
index 33ad57e2706..ba8e0c08798 100644
--- a/test/unit/math/prim/fun/value_of_test.cpp
+++ b/test/unit/math/prim/fun/value_of_test.cpp
@@ -81,21 +81,21 @@ TEST(MathFunctions, value_of_vector_of_vectors) {
   std::vector<std::vector<double>> va(5, a);
   const std::vector<std::vector<double>> vb(5, b);
   EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(va)),
-	       std::vector<std::vector<double>>&>::value));
+                            std::vector<std::vector<double>>&>::value));
   EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(vb)),
-	       const std::vector<std::vector<double>>&>::value));
+                            const std::vector<std::vector<double>>&>::value));
 
   auto vva = stan::math::value_of(va);
   auto vvb = stan::math::value_of(va);
 
-  for(size_t i = 0; i < va.size(); ++i) {
-    for(size_t j = 0; j < va[i].size(); ++j) {
+  for (size_t i = 0; i < va.size(); ++i) {
+    for (size_t j = 0; j < va[i].size(); ++j) {
       EXPECT_FLOAT_EQ(vva[i][j], a[j]);
     }
   }
 
-  for(size_t i = 0; i < vb.size(); ++i) {
-    for(size_t j = 0; j < vb[i].size(); ++j) {
+  for (size_t i = 0; i < vb.size(); ++i) {
+    for (size_t j = 0; j < vb[i].size(); ++j) {
       EXPECT_FLOAT_EQ(vvb[i][j], b[j]);
     }
   }
@@ -109,23 +109,23 @@ TEST(MathFunctions, value_of_vector_of_eigen) {
   std::vector<Eigen::RowVectorXd> vb(5, b);
   std::vector<Eigen::MatrixXd> vc(5, c);
   EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(va)),
-	       std::vector<Eigen::VectorXd>&>::value));
+                            std::vector<Eigen::VectorXd>&>::value));
   EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(vb)),
-	       std::vector<Eigen::RowVectorXd>&>::value));
+                            std::vector<Eigen::RowVectorXd>&>::value));
   EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(vc)),
-	       std::vector<Eigen::MatrixXd>&>::value));
+                            std::vector<Eigen::MatrixXd>&>::value));
 
   auto vva = stan::math::value_of(va);
   auto vvb = stan::math::value_of(vb);
   auto vvc = stan::math::value_of(vc);
 
-  for(size_t i = 0; i < vva.size(); ++i)
+  for (size_t i = 0; i < vva.size(); ++i)
     EXPECT_MATRIX_FLOAT_EQ(vva[i], a);
 
-  for(size_t i = 0; i < vvb.size(); ++i)
+  for (size_t i = 0; i < vvb.size(); ++i)
     EXPECT_MATRIX_FLOAT_EQ(vvb[i], b);
 
-  for(size_t i = 0; i < vvc.size(); ++i)
+  for (size_t i = 0; i < vvc.size(); ++i)
     EXPECT_MATRIX_FLOAT_EQ(vvc[i], c);
 }
 
diff --git a/test/unit/math/prim/functor/harmonic_oscillator.hpp b/test/unit/math/prim/functor/harmonic_oscillator.hpp
index 7a236786ec6..21dfa3d089d 100644
--- a/test/unit/math/prim/functor/harmonic_oscillator.hpp
+++ b/test/unit/math/prim/functor/harmonic_oscillator.hpp
@@ -30,10 +30,11 @@ struct harm_osc_ode_fun {
 
 struct harm_osc_ode_fun_eigen {
   template <typename T0, typename T1, typename T2>
-  inline auto
-  operator()(const T0& t_in, const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y_in, std::ostream* msgs,
-             const std::vector<T2>& theta, const std::vector<double>& x,
-             const std::vector<int>& x_int) const {
+  inline auto operator()(const T0& t_in,
+                         const Eigen::Matrix<T1, Eigen::Dynamic, 1>& y_in,
+                         std::ostream* msgs, const std::vector<T2>& theta,
+                         const std::vector<double>& x,
+                         const std::vector<int>& x_int) const {
     if (y_in.size() != 2)
       throw std::domain_error(
           "this function was called with inconsistent state");
diff --git a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
index 2173c5f750f..9b18f551ae7 100644
--- a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
@@ -160,13 +160,13 @@ TEST(ode_rk45_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  std::vector<std::vector<double>> vva = { va };
-  std::vector<std::vector<double>> vvainf = { vainf };
-  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+  std::vector<std::vector<double>> vva = {va};
+  std::vector<std::vector<double>> vvainf = {vainf};
+  std::vector<std::vector<double>> vvaNaN = {vaNaN};
 
-  std::vector<Eigen::VectorXd> vea = { ea };
-  std::vector<Eigen::VectorXd> veainf = { eainf };
-  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+  std::vector<Eigen::VectorXd> vea = {ea};
+  std::vector<Eigen::VectorXd> veainf = {eainf};
+  std::vector<Eigen::VectorXd> veaNaN = {eaNaN};
 
   EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a));
 
@@ -229,13 +229,13 @@ TEST(ode_rk45_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  std::vector<std::vector<double>> vva = { va };
-  std::vector<std::vector<double>> vvainf = { vainf };
-  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+  std::vector<std::vector<double>> vva = {va};
+  std::vector<std::vector<double>> vvainf = {vainf};
+  std::vector<std::vector<double>> vvaNaN = {vaNaN};
 
-  std::vector<Eigen::VectorXd> vea = { ea };
-  std::vector<Eigen::VectorXd> veainf = { eainf };
-  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+  std::vector<Eigen::VectorXd> vea = {ea};
+  std::vector<Eigen::VectorXd> veainf = {eainf};
+  std::vector<Eigen::VectorXd> veaNaN = {eaNaN};
 
   EXPECT_NO_THROW(stan::math::ode_rk45(Cos2Arg(), y0, t0, ts, nullptr, a, a));
 
diff --git a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
index 6dbbc8ae39f..cae41261fe9 100644
--- a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
@@ -173,13 +173,13 @@ TEST(ode_rk45_tol_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  std::vector<std::vector<double>> vva = { va };
-  std::vector<std::vector<double>> vvainf = { vainf };
-  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+  std::vector<std::vector<double>> vva = {va};
+  std::vector<std::vector<double>> vvainf = {vainf};
+  std::vector<std::vector<double>> vvaNaN = {vaNaN};
 
-  std::vector<Eigen::VectorXd> vea = { ea };
-  std::vector<Eigen::VectorXd> veainf = { eainf };
-  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+  std::vector<Eigen::VectorXd> vea = {ea};
+  std::vector<Eigen::VectorXd> veainf = {eainf};
+  std::vector<Eigen::VectorXd> veaNaN = {eaNaN};
 
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
                                            1e6, nullptr, a));
@@ -257,13 +257,13 @@ TEST(ode_rk45_tol_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  std::vector<std::vector<double>> vva = { va };
-  std::vector<std::vector<double>> vvainf = { vainf };
-  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+  std::vector<std::vector<double>> vva = {va};
+  std::vector<std::vector<double>> vvainf = {vainf};
+  std::vector<std::vector<double>> vvaNaN = {vaNaN};
 
-  std::vector<Eigen::VectorXd> vea = { ea };
-  std::vector<Eigen::VectorXd> veainf = { eainf };
-  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+  std::vector<Eigen::VectorXd> vea = {ea};
+  std::vector<Eigen::VectorXd> veainf = {eainf};
+  std::vector<Eigen::VectorXd> veaNaN = {eaNaN};
 
   EXPECT_NO_THROW(stan::math::ode_rk45_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
                                            1e6, nullptr, a, a));
diff --git a/test/unit/math/rev/fun/value_of_test.cpp b/test/unit/math/rev/fun/value_of_test.cpp
index 3178ab1fc24..379a0f41fb3 100644
--- a/test/unit/math/rev/fun/value_of_test.cpp
+++ b/test/unit/math/rev/fun/value_of_test.cpp
@@ -94,21 +94,21 @@ TEST(AgradMatrix, value_of_vector_of_vectors) {
   std::vector<std::vector<var>> va(5, a);
   const std::vector<std::vector<var>> vb(5, b);
   EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(va)),
-	       std::vector<std::vector<double>>>::value));
+                            std::vector<std::vector<double>>>::value));
   EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(vb)),
-	       std::vector<std::vector<double>>>::value));
+                            std::vector<std::vector<double>>>::value));
 
   auto vva = stan::math::value_of(va);
   auto vvb = stan::math::value_of(va);
 
-  for(size_t i = 0; i < va.size(); ++i) {
-    for(size_t j = 0; j < va[i].size(); ++j) {
+  for (size_t i = 0; i < va.size(); ++i) {
+    for (size_t j = 0; j < va[i].size(); ++j) {
       EXPECT_FLOAT_EQ(vva[i][j], a[j].val());
     }
   }
 
-  for(size_t i = 0; i < vb.size(); ++i) {
-    for(size_t j = 0; j < vb[i].size(); ++j) {
+  for (size_t i = 0; i < vb.size(); ++i) {
+    for (size_t j = 0; j < vb[i].size(); ++j) {
       EXPECT_FLOAT_EQ(vvb[i][j], b[j].val());
     }
   }
@@ -116,36 +116,36 @@ TEST(AgradMatrix, value_of_vector_of_vectors) {
 
 TEST(MathFunctions, value_of_vector_of_eigen) {
   using stan::math::var;
-  Eigen::Matrix<var, Eigen::Dynamic, 1> a =
-    Eigen::VectorXd::Random(5).template cast<var>();
-  Eigen::Matrix<var, 1, Eigen::Dynamic> b =
-    Eigen::RowVectorXd::Random(5).template cast<var>();
-  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> c =
-    Eigen::MatrixXd::Random(5, 5).template cast<var>();
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a
+      = Eigen::VectorXd::Random(5).template cast<var>();
+  Eigen::Matrix<var, 1, Eigen::Dynamic> b
+      = Eigen::RowVectorXd::Random(5).template cast<var>();
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> c
+      = Eigen::MatrixXd::Random(5, 5).template cast<var>();
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> va(5, a);
   std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> vb(5, b);
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> vc(5, c);
   EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(va)),
-	       std::vector<Eigen::VectorXd>>::value));
+                            std::vector<Eigen::VectorXd>>::value));
   EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(vb)),
-	       std::vector<Eigen::RowVectorXd>>::value));
+                            std::vector<Eigen::RowVectorXd>>::value));
   EXPECT_TRUE((std::is_same<decltype(stan::math::value_of(vc)),
-	       std::vector<Eigen::MatrixXd>>::value));
+                            std::vector<Eigen::MatrixXd>>::value));
 
   auto vva = stan::math::value_of(va);
   auto vvb = stan::math::value_of(vb);
   auto vvc = stan::math::value_of(vc);
 
-  for(size_t i = 0; i < vva.size(); ++i)
-    for(size_t j = 0; j < vva[i].size(); ++j)
+  for (size_t i = 0; i < vva.size(); ++i)
+    for (size_t j = 0; j < vva[i].size(); ++j)
       EXPECT_FLOAT_EQ(vva[i](j), a(j).val());
 
-  for(size_t i = 0; i < vvb.size(); ++i)
-    for(size_t j = 0; j < vva[i].size(); ++j)
+  for (size_t i = 0; i < vvb.size(); ++i)
+    for (size_t j = 0; j < vva[i].size(); ++j)
       EXPECT_FLOAT_EQ(vvb[i](j), b(j).val());
 
-  for(size_t i = 0; i < vvc.size(); ++i)
-    for(size_t j = 0; j < vva[i].size(); ++j)
+  for (size_t i = 0; i < vvc.size(); ++i)
+    for (size_t j = 0; j < vva[i].size(); ++j)
       EXPECT_FLOAT_EQ(vvc[i](j), c(j).val());
 }
 
@@ -177,4 +177,3 @@ TEST(AgradMatrixRev, value_of_matrix_rvalue) {
 
   EXPECT_MATRIX_NEAR(res, correct, 1e-10);
 }
-
diff --git a/test/unit/math/rev/functor/coupled_ode_system_test.cpp b/test/unit/math/rev/functor/coupled_ode_system_test.cpp
index be4739c1b21..e513a20a3c3 100644
--- a/test/unit/math/rev/functor/coupled_ode_system_test.cpp
+++ b/test/unit/math/rev/functor/coupled_ode_system_test.cpp
@@ -43,10 +43,9 @@ TEST_F(StanAgradRevOde, coupled_ode_system_dv) {
 
   std::size_t stack_size = stan::math::nested_size();
 
-  coupled_ode_system<decltype(harm_osc), double,
-		     std::vector<stan::math::var>,
-		     std::vector<double>, std::vector<int>> system(
-      harm_osc, y0, &msgs, theta, x, x_int);
+  coupled_ode_system<decltype(harm_osc), double, std::vector<stan::math::var>,
+                     std::vector<double>, std::vector<int>>
+      system(harm_osc, y0, &msgs, theta, x, x_int);
 
   EXPECT_EQ(stack_size, stan::math::nested_size())
       << "expecting no new things on the stack";
@@ -76,10 +75,9 @@ TEST_F(StanAgradRevOde, initial_state_dv) {
   for (size_t m = 0; m < M; m++)
     theta_v[m] = 10 * (m + 1);
 
-  coupled_ode_system<decltype(base_ode), double,
-		     std::vector<stan::math::var>,
-		     std::vector<double>, std::vector<int>> coupled_system_dv(
-      base_ode, y0_d, &msgs, theta_v, x, x_int);
+  coupled_ode_system<decltype(base_ode), double, std::vector<stan::math::var>,
+                     std::vector<double>, std::vector<int>>
+      coupled_system_dv(base_ode, y0_d, &msgs, theta_v, x, x_int);
 
   std::vector<double> state = coupled_system_dv.initial_state();
   for (size_t n = 0; n < N; n++)
@@ -102,10 +100,9 @@ TEST_F(StanAgradRevOde, size_dv) {
   Eigen::VectorXd y0_d = Eigen::VectorXd::Zero(N);
   std::vector<var> theta_v(M, 0.0);
 
-  coupled_ode_system<decltype(base_ode), double,
-		     std::vector<stan::math::var>,
-		     std::vector<double>, std::vector<int>> coupled_system_dv(
-      base_ode, y0_d, &msgs, theta_v, x, x_int);
+  coupled_ode_system<decltype(base_ode), double, std::vector<stan::math::var>,
+                     std::vector<double>, std::vector<int>>
+      coupled_system_dv(base_ode, y0_d, &msgs, theta_v, x, x_int);
 
   EXPECT_EQ(z_size, coupled_system_dv.size());
 }
@@ -122,10 +119,9 @@ TEST_F(StanAgradRevOde, memory_recovery_dv) {
   Eigen::VectorXd y0_d = Eigen::VectorXd::Zero(N);
   std::vector<var> theta_v(M, 0.0);
 
-  coupled_ode_system<decltype(base_ode), double,
-		     std::vector<stan::math::var>,
-		     std::vector<double>, std::vector<int>> coupled_system_dv(
-      base_ode, y0_d, &msgs, theta_v, x, x_int);
+  coupled_ode_system<decltype(base_ode), double, std::vector<stan::math::var>,
+                     std::vector<double>, std::vector<int>>
+      coupled_system_dv(base_ode, y0_d, &msgs, theta_v, x, x_int);
 
   std::vector<double> z(z_size, 0);
   std::vector<double> dz_dt(z_size, 0);
@@ -155,9 +151,9 @@ TEST_F(StanAgradRevOde, memory_recovery_exception_dv) {
     std::vector<var> theta_v(M, 0.0);
 
     coupled_ode_system<decltype(throwing_ode), double,
-		       std::vector<stan::math::var>,
-		       std::vector<double>, std::vector<int>>
-      coupled_system_dv(throwing_ode, y0_d, &msgs, theta_v, x, x_int);
+                       std::vector<stan::math::var>, std::vector<double>,
+                       std::vector<int>>
+        coupled_system_dv(throwing_ode, y0_d, &msgs, theta_v, x, x_int);
 
     std::vector<double> z(z_size, 0);
     std::vector<double> dz_dt(z_size, 0);
@@ -204,10 +200,9 @@ TEST_F(StanAgradRevOde, coupled_ode_system_vd) {
 
   std::size_t stack_size = stan::math::nested_size();
 
-  coupled_ode_system<decltype(harm_osc), stan::math::var,
-		       std::vector<double>,
-		       std::vector<double>, std::vector<int>>
-    system(harm_osc, y0_var, &msgs, theta, x, x_int);
+  coupled_ode_system<decltype(harm_osc), stan::math::var, std::vector<double>,
+                     std::vector<double>, std::vector<int>>
+      system(harm_osc, y0_var, &msgs, theta, x, x_int);
 
   EXPECT_EQ(stack_size, stan::math::nested_size())
       << "expecting no new things on the stack";
@@ -230,8 +225,8 @@ TEST_F(StanAgradRevOde, initial_state_vd) {
   const size_t N = 3;
   const size_t M = 4;
 
-  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v =
-    Eigen::VectorXd::Zero(N).template cast<var>();
+  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v
+      = Eigen::VectorXd::Zero(N).template cast<var>();
   std::vector<double> theta_d(M, 0.0);
 
   for (size_t n = 0; n < N; n++)
@@ -239,10 +234,9 @@ TEST_F(StanAgradRevOde, initial_state_vd) {
   for (size_t m = 0; m < M; m++)
     theta_d[m] = 10 * (m + 1);
 
-  coupled_ode_system<decltype(base_ode), stan::math::var,
-		       std::vector<double>,
-		       std::vector<double>, std::vector<int>>
-    coupled_system_vd(base_ode, y0_v, &msgs, theta_d, x, x_int);
+  coupled_ode_system<decltype(base_ode), stan::math::var, std::vector<double>,
+                     std::vector<double>, std::vector<int>>
+      coupled_system_vd(base_ode, y0_v, &msgs, theta_d, x, x_int);
 
   std::vector<double> state;
 
@@ -263,14 +257,13 @@ TEST_F(StanAgradRevOde, size_vd) {
   const size_t M = 4;
   const size_t z_size = N + N * N;
 
-  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v =
-    Eigen::VectorXd::Zero(N).template cast<var>();
+  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v
+      = Eigen::VectorXd::Zero(N).template cast<var>();
   std::vector<double> theta_d(M, 0.0);
 
-  coupled_ode_system<decltype(base_ode), stan::math::var,
-		       std::vector<double>,
-		       std::vector<double>, std::vector<int>>
-    coupled_system_vd(base_ode, y0_v, &msgs, theta_d, x, x_int);
+  coupled_ode_system<decltype(base_ode), stan::math::var, std::vector<double>,
+                     std::vector<double>, std::vector<int>>
+      coupled_system_vd(base_ode, y0_v, &msgs, theta_d, x, x_int);
 
   EXPECT_EQ(z_size, coupled_system_vd.size());
 }
@@ -284,14 +277,13 @@ TEST_F(StanAgradRevOde, memory_recovery_vd) {
   const size_t M = 4;
   const size_t z_size = N + N * N;
 
-  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v =
-    Eigen::VectorXd::Zero(N).template cast<var>();
+  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v
+      = Eigen::VectorXd::Zero(N).template cast<var>();
   std::vector<double> theta_d(M, 0.0);
 
-  coupled_ode_system<decltype(base_ode), stan::math::var,
-		     std::vector<double>,
-		     std::vector<double>, std::vector<int>>
-    coupled_system_vd(base_ode, y0_v, &msgs, theta_d, x, x_int);
+  coupled_ode_system<decltype(base_ode), stan::math::var, std::vector<double>,
+                     std::vector<double>, std::vector<int>>
+      coupled_system_vd(base_ode, y0_v, &msgs, theta_d, x, x_int);
 
   std::vector<double> z(z_size, 0);
   std::vector<double> dz_dt(z_size, 0);
@@ -317,14 +309,14 @@ TEST_F(StanAgradRevOde, memory_recovery_exception_vd) {
     SCOPED_TRACE(scoped_message.str());
     mock_throwing_ode_functor<std::logic_error> throwing_ode(message, 1);
 
-  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v =
-    Eigen::VectorXd::Zero(N).template cast<var>();
+    Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v
+        = Eigen::VectorXd::Zero(N).template cast<var>();
     std::vector<double> theta_d(M, 0.0);
 
     coupled_ode_system<decltype(throwing_ode), stan::math::var,
-		       std::vector<double>,
-		       std::vector<double>, std::vector<int>>
-      coupled_system_vd(throwing_ode, y0_v, &msgs, theta_d, x, x_int);
+                       std::vector<double>, std::vector<double>,
+                       std::vector<int>>
+        coupled_system_vd(throwing_ode, y0_v, &msgs, theta_d, x, x_int);
 
     std::vector<double> z(z_size, 0);
     std::vector<double> dz_dt(z_size, 0);
@@ -359,9 +351,9 @@ TEST_F(StanAgradRevOde, coupled_ode_system_vv) {
   std::size_t stack_size = stan::math::nested_size();
 
   coupled_ode_system<decltype(harm_osc), stan::math::var,
-		     std::vector<stan::math::var>,
-		     std::vector<double>, std::vector<int>>
-    system(harm_osc, y0_var, &msgs, theta_var, x, x_int);
+                     std::vector<stan::math::var>, std::vector<double>,
+                     std::vector<int>>
+      system(harm_osc, y0_var, &msgs, theta_var, x, x_int);
 
   EXPECT_EQ(stack_size, stan::math::nested_size())
       << "expecting no new things on the stack";
@@ -405,8 +397,8 @@ TEST_F(StanAgradRevOde, initial_state_vv) {
   const size_t N = 3;
   const size_t M = 4;
 
-  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v =
-    Eigen::VectorXd::Zero(N).template cast<var>();
+  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v
+      = Eigen::VectorXd::Zero(N).template cast<var>();
   std::vector<var> theta_v(M, 0.0);
 
   for (size_t n = 0; n < N; n++)
@@ -415,9 +407,9 @@ TEST_F(StanAgradRevOde, initial_state_vv) {
     theta_v[m] = 10 * (m + 1);
 
   coupled_ode_system<decltype(base_ode), stan::math::var,
-		     std::vector<stan::math::var>,
-		     std::vector<double>, std::vector<int>>
-    coupled_system_vv(base_ode, y0_v, &msgs, theta_v, x, x_int);
+                     std::vector<stan::math::var>, std::vector<double>,
+                     std::vector<int>>
+      coupled_system_vv(base_ode, y0_v, &msgs, theta_v, x, x_int);
 
   std::vector<double> state = coupled_system_vv.initial_state();
   for (size_t n = 0; n < N; n++)
@@ -438,14 +430,14 @@ TEST_F(StanAgradRevOde, size_vv) {
   const size_t M = 4;
   const size_t z_size = N + N * N + N * M;
 
-  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v =
-    Eigen::VectorXd::Zero(N).template cast<var>();
+  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v
+      = Eigen::VectorXd::Zero(N).template cast<var>();
   std::vector<var> theta_v(M, 0.0);
 
   coupled_ode_system<decltype(base_ode), stan::math::var,
-		     std::vector<stan::math::var>,
-		     std::vector<double>, std::vector<int>>
-    coupled_system_vv(base_ode, y0_v, &msgs, theta_v, x, x_int);
+                     std::vector<stan::math::var>, std::vector<double>,
+                     std::vector<int>>
+      coupled_system_vv(base_ode, y0_v, &msgs, theta_v, x, x_int);
 
   EXPECT_EQ(z_size, coupled_system_vv.size());
 }
@@ -459,14 +451,14 @@ TEST_F(StanAgradRevOde, memory_recovery_vv) {
   const size_t M = 4;
   const size_t z_size = N + N * N + N * M;
 
-  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v =
-    Eigen::VectorXd::Zero(N).template cast<var>();
+  Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v
+      = Eigen::VectorXd::Zero(N).template cast<var>();
   std::vector<var> theta_v(M, 0.0);
 
   coupled_ode_system<decltype(base_ode), stan::math::var,
-		     std::vector<stan::math::var>,
-		     std::vector<double>, std::vector<int>>
-    coupled_system_vv(base_ode, y0_v, &msgs, theta_v, x, x_int);
+                     std::vector<stan::math::var>, std::vector<double>,
+                     std::vector<int>>
+      coupled_system_vv(base_ode, y0_v, &msgs, theta_v, x, x_int);
 
   std::vector<double> z(z_size, 0);
   std::vector<double> dz_dt(z_size, 0);
@@ -492,14 +484,14 @@ TEST_F(StanAgradRevOde, memory_recovery_exception_vv) {
     SCOPED_TRACE(scoped_message.str());
     mock_throwing_ode_functor<std::logic_error> throwing_ode(message, 1);
 
-    Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v =
-      Eigen::VectorXd::Zero(N).template cast<var>();
+    Eigen::Matrix<stan::math::var, Eigen::Dynamic, 1> y0_v
+        = Eigen::VectorXd::Zero(N).template cast<var>();
     std::vector<var> theta_v(M, 0.0);
 
     coupled_ode_system<decltype(throwing_ode), stan::math::var,
-		       std::vector<stan::math::var>,
-		       std::vector<double>, std::vector<int>>
-      coupled_system_vv(throwing_ode, y0_v, &msgs, theta_v, x, x_int);
+                       std::vector<stan::math::var>, std::vector<double>,
+                       std::vector<int>>
+        coupled_system_vv(throwing_ode, y0_v, &msgs, theta_v, x, x_int);
 
     std::vector<double> z(z_size, 0);
     std::vector<double> dz_dt(z_size, 0);
@@ -533,10 +525,11 @@ auto sum_(Vec&& arg) {
 struct ayt {
   template <typename T0, typename T_y, typename... T_Args>
   inline auto operator()(const T0& t, const T_y& y, std::ostream* msgs,
-			 const T_Args&... args) const {
+                         const T_Args&... args) const {
     std::vector<typename stan::return_type<T_Args...>::type> vec
         = {sum_(args)...};
-    Eigen::Matrix<stan::return_type_t<T0, T_y, T_Args...>, Eigen::Dynamic, 1> out(2);
+    Eigen::Matrix<stan::return_type_t<T0, T_y, T_Args...>, Eigen::Dynamic, 1>
+        out(2);
     out(0) = -sum_(vec) * y(0) * t;
     out(1) = -1.7 * sum_(vec) * y(1) * t;
     return out;
@@ -556,11 +549,10 @@ TEST_F(StanAgradRevOde, coupled_ode_system_var) {
 
   ayt func;
 
-  coupled_ode_system<ayt, stan::math::var,
-		     decltype(av)>
-    system(func, y0v, &msgs, av);
+  coupled_ode_system<ayt, stan::math::var, decltype(av)> system(func, y0v,
+                                                                &msgs, av);
 
-  std::vector<double> z = { y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2 };
+  std::vector<double> z = {y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2};
 
   double t0 = 0.75;
 
@@ -585,15 +577,14 @@ TEST_F(StanAgradRevOde, coupled_ode_system_std_vector) {
   y0 << 0.1, 0.2;
   Eigen::Matrix<var, Eigen::Dynamic, 1> y0v = y0.template cast<var>();
 
-  std::vector<var> av = { 1.3 };
+  std::vector<var> av = {1.3};
 
   ayt func;
 
-  coupled_ode_system<ayt, stan::math::var,
-		     decltype(av)>
-    system(func, y0v, &msgs, av);
+  coupled_ode_system<ayt, stan::math::var, decltype(av)> system(func, y0v,
+                                                                &msgs, av);
 
-  std::vector<double> z = { y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2 };
+  std::vector<double> z = {y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2};
 
   double t0 = 0.75;
 
@@ -619,15 +610,14 @@ TEST_F(StanAgradRevOde, coupled_ode_system_vector) {
   Eigen::Matrix<var, Eigen::Dynamic, 1> y0v = y0.template cast<var>();
 
   Eigen::Matrix<var, Eigen::Dynamic, 1> av(1);
-  av << 1.3 ;
+  av << 1.3;
 
   ayt func;
 
-  coupled_ode_system<ayt, stan::math::var,
-		     decltype(av)>
-    system(func, y0v, &msgs, av);
+  coupled_ode_system<ayt, stan::math::var, decltype(av)> system(func, y0v,
+                                                                &msgs, av);
 
-  std::vector<double> z = { y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2 };
+  std::vector<double> z = {y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2};
 
   double t0 = 0.75;
 
@@ -653,15 +643,14 @@ TEST_F(StanAgradRevOde, coupled_ode_system_row_vector) {
   Eigen::Matrix<var, Eigen::Dynamic, 1> y0v = y0.template cast<var>();
 
   Eigen::Matrix<var, 1, Eigen::Dynamic> av(1);
-  av << 1.3 ;
+  av << 1.3;
 
   ayt func;
 
-  coupled_ode_system<ayt, stan::math::var,
-		     decltype(av)>
-    system(func, y0v, &msgs, av);
+  coupled_ode_system<ayt, stan::math::var, decltype(av)> system(func, y0v,
+                                                                &msgs, av);
 
-  std::vector<double> z = { y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2 };
+  std::vector<double> z = {y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2};
 
   double t0 = 0.75;
 
@@ -687,15 +676,14 @@ TEST_F(StanAgradRevOde, coupled_ode_system_matrix) {
   Eigen::Matrix<var, Eigen::Dynamic, 1> y0v = y0.template cast<var>();
 
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> av(1, 1);
-  av << 1.3 ;
+  av << 1.3;
 
   ayt func;
 
-  coupled_ode_system<ayt, stan::math::var,
-		     decltype(av)>
-    system(func, y0v, &msgs, av);
+  coupled_ode_system<ayt, stan::math::var, decltype(av)> system(func, y0v,
+                                                                &msgs, av);
 
-  std::vector<double> z = { y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2 };
+  std::vector<double> z = {y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2};
 
   double t0 = 0.75;
 
@@ -724,7 +712,7 @@ TEST_F(StanAgradRevOde, coupled_ode_system_extra_args) {
   av << -0.2;
   int e1 = 1;
   double e2 = 0.1;
-  std::vector<double> e3 = { 0.1 };
+  std::vector<double> e3 = {0.1};
   Eigen::VectorXd e4(1);
   e4 << 0.1;
   Eigen::VectorXd e5(1);
@@ -734,13 +722,12 @@ TEST_F(StanAgradRevOde, coupled_ode_system_extra_args) {
 
   ayt func;
 
-  coupled_ode_system<ayt, stan::math::var,
-		     decltype(av),
-		     decltype(e1), decltype(e2), decltype(e3),
-		     decltype(e4), decltype(e5), decltype(e6)>
-    system(func, y0v, &msgs, av, e1, e2, e3, e4, e5, e6);
+  coupled_ode_system<ayt, stan::math::var, decltype(av), decltype(e1),
+                     decltype(e2), decltype(e3), decltype(e4), decltype(e5),
+                     decltype(e6)>
+      system(func, y0v, &msgs, av, e1, e2, e3, e4, e5, e6);
 
-  std::vector<double> z = { y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2 };
+  std::vector<double> z = {y0(0), y0(1), 3.2, 3.3, 4.4, 4.5, 2.1, 2.2};
 
   double t0 = 0.75;
 
diff --git a/test/unit/math/rev/functor/ode_adams_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
index 84cc4dad8cb..5259bdd86f6 100644
--- a/test/unit/math/rev/functor/ode_adams_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
@@ -161,13 +161,13 @@ TEST(ode_adams_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  std::vector<std::vector<double>> vva = { va };
-  std::vector<std::vector<double>> vvainf = { vainf };
-  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+  std::vector<std::vector<double>> vva = {va};
+  std::vector<std::vector<double>> vvainf = {vainf};
+  std::vector<std::vector<double>> vvaNaN = {vaNaN};
 
-  std::vector<Eigen::VectorXd> vea = { ea };
-  std::vector<Eigen::VectorXd> veainf = { eainf };
-  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+  std::vector<Eigen::VectorXd> vea = {ea};
+  std::vector<Eigen::VectorXd> veainf = {eainf};
+  std::vector<Eigen::VectorXd> veaNaN = {eaNaN};
 
   EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a));
 
@@ -230,13 +230,13 @@ TEST(ode_adams_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  std::vector<std::vector<double>> vva = { va };
-  std::vector<std::vector<double>> vvainf = { vainf };
-  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+  std::vector<std::vector<double>> vva = {va};
+  std::vector<std::vector<double>> vvainf = {vainf};
+  std::vector<std::vector<double>> vvaNaN = {vaNaN};
 
-  std::vector<Eigen::VectorXd> vea = { ea };
-  std::vector<Eigen::VectorXd> veainf = { eainf };
-  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+  std::vector<Eigen::VectorXd> vea = {ea};
+  std::vector<Eigen::VectorXd> veainf = {eainf};
+  std::vector<Eigen::VectorXd> veaNaN = {eaNaN};
 
   EXPECT_NO_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, a));
 
@@ -262,7 +262,8 @@ TEST(ode_adams_prim, two_arg_errors) {
   EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, eaNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, vva));
+  EXPECT_NO_THROW(
+      stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, vva));
 
   EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, vvainf),
                std::domain_error);
@@ -270,7 +271,8 @@ TEST(ode_adams_prim, two_arg_errors) {
   EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, vvaNaN),
                std::domain_error);
 
-  EXPECT_NO_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, vea));
+  EXPECT_NO_THROW(
+      stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, vea));
 
   EXPECT_THROW(stan::math::ode_adams(Cos2Arg(), y0, t0, ts, nullptr, a, veainf),
                std::domain_error);
diff --git a/test/unit/math/rev/functor/ode_adams_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
index 4a19cd01bdb..9409652cdda 100644
--- a/test/unit/math/rev/functor/ode_adams_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
@@ -314,8 +314,7 @@ TEST(StanMathOde_ode_adams, std_vector_std_vector_args) {
   std::vector<var> a1(1, a0);
   std::vector<std::vector<var>> a2(1, a1);
 
-  var output
-      = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
 
   output.grad();
 
@@ -335,8 +334,7 @@ TEST(StanMathOde_ode_adams, std_vector_vector_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> a2(1, a1);
 
-  var output
-      = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
 
   output.grad();
 
@@ -356,8 +354,7 @@ TEST(StanMathOde_ode_adams, std_vector_row_vector_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> a2(1, a1);
 
-  var output
-      = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
 
   output.grad();
 
@@ -377,8 +374,7 @@ TEST(StanMathOde_ode_adams, std_vector_matrix_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> a2(1, a1);
 
-  var output
-      = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+  var output = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
 
   output.grad();
 
@@ -408,30 +404,33 @@ TEST(StanMathOde_ode_adams, arg_combos_test) {
 
   auto check_yT = [&](auto yT) {
     EXPECT_NEAR(stan::math::value_of(yT),
-                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
+                y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   auto check_t0 = [&](var t0) {
     EXPECT_NEAR(
         t0.adj(),
-        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)),
+        1e-5);
   };
 
   auto check_a = [&](var a) {
     EXPECT_NEAR(a.adj(),
-                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
-                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
+                -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                    * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)),
+                1e-5);
   };
 
   auto check_ts = [&](std::vector<var> ts) {
     EXPECT_NEAR(
         ts[0].adj(),
-        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)),
+        1e-5);
   };
 
   auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
-    EXPECT_NEAR(y0(0).adj(),
-                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
+    EXPECT_NEAR(y0(0).adj(), exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)),
+                1e-5);
   };
 
   double yT1 = stan::math::ode_adams(ayt(), y0d, t0d, tsd, nullptr, ad)[0](0);
diff --git a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
index cad840d8a83..8e61ba88fe2 100644
--- a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
@@ -73,18 +73,18 @@ TEST(ode_adams_tol_prim, y0_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a));
+                                            1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0inf, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0NaN, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0_empty, t0, ts, 1e-10,
-                                        1e-10, 1e6, nullptr, a),
+                                         1e-10, 1e6, nullptr, a),
                std::invalid_argument);
 }
 
@@ -98,14 +98,14 @@ TEST(ode_adams_tol_prim, t0_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a));
+                                            1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0inf, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0NaN, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -124,32 +124,32 @@ TEST(ode_adams_tol_prim, ts_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a));
+                                            1e6, nullptr, a));
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
-                                           1e-10, 1e6, nullptr, a));
+                                            1e-10, 1e6, nullptr, a));
 
-    EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
-                                           1e-10, 1e6, nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
+                                            1e-10, 1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
-                                        1e-10, 1e6, nullptr, a),
+                                         1e-10, 1e6, nullptr, a),
                std::invalid_argument);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_early, 1e-10,
-                                        1e-10, 1e6, nullptr, a),
+                                         1e-10, 1e6, nullptr, a),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_decreasing, 1e-10,
-                                        1e-10, 1e6, nullptr, a),
+  EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_decreasing,
+                                         1e-10, 1e-10, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, tsinf, 1e-10, 1e-10,
-                                        1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, tsNaN, 1e-10, 1e-10,
-                                        1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -173,67 +173,67 @@ TEST(ode_adams_tol_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  std::vector<std::vector<double>> vva = { va };
-  std::vector<std::vector<double>> vvainf = { vainf };
-  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+  std::vector<std::vector<double>> vva = {va};
+  std::vector<std::vector<double>> vvainf = {vainf};
+  std::vector<std::vector<double>> vvaNaN = {vaNaN};
 
-  std::vector<Eigen::VectorXd> vea = { ea };
-  std::vector<Eigen::VectorXd> veainf = { eainf };
-  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+  std::vector<Eigen::VectorXd> vea = {ea};
+  std::vector<Eigen::VectorXd> veainf = {eainf};
+  std::vector<Eigen::VectorXd> veaNaN = {eaNaN};
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a));
+                                            1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, ainf),
+                                         1e6, nullptr, ainf),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, aNaN),
+                                         1e6, nullptr, aNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, va));
+                                            1e6, nullptr, va));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, vainf),
+                                         1e6, nullptr, vainf),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, vaNaN),
+                                         1e6, nullptr, vaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, ea));
+                                            1e6, nullptr, ea));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, eainf),
+                                         1e6, nullptr, eainf),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, eaNaN),
+                                         1e6, nullptr, eaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, vva));
+                                            1e6, nullptr, vva));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, vvainf),
+                                         1e6, nullptr, vvainf),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, vvaNaN),
+                                         1e6, nullptr, vvaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, vea));
+                                            1e6, nullptr, vea));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, veainf),
+                                         1e6, nullptr, veainf),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, veaNaN),
+                                         1e6, nullptr, veaNaN),
                std::domain_error);
 }
 
@@ -257,67 +257,67 @@ TEST(ode_adams_tol_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  std::vector<std::vector<double>> vva = { va };
-  std::vector<std::vector<double>> vvainf = { vainf };
-  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+  std::vector<std::vector<double>> vva = {va};
+  std::vector<std::vector<double>> vvainf = {vainf};
+  std::vector<std::vector<double>> vvaNaN = {vaNaN};
 
-  std::vector<Eigen::VectorXd> vea = { ea };
-  std::vector<Eigen::VectorXd> veainf = { eainf };
-  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+  std::vector<Eigen::VectorXd> vea = {ea};
+  std::vector<Eigen::VectorXd> veainf = {eainf};
+  std::vector<Eigen::VectorXd> veaNaN = {eaNaN};
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a, a));
+                                            1e6, nullptr, a, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, ainf),
+                                         1e6, nullptr, a, ainf),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, aNaN),
+                                         1e6, nullptr, a, aNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a, va));
+                                            1e6, nullptr, a, va));
 
   EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, vainf),
+                                         1e6, nullptr, a, vainf),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, vaNaN),
+                                         1e6, nullptr, a, vaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a, ea));
+                                            1e6, nullptr, a, ea));
 
   EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, eainf),
+                                         1e6, nullptr, a, eainf),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, eaNaN),
+                                         1e6, nullptr, a, eaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a, vva));
+                                            1e6, nullptr, a, vva));
 
   EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, vvainf),
+                                         1e6, nullptr, a, vvainf),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, vvaNaN),
+                                         1e6, nullptr, a, vvaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a, vea));
+                                            1e6, nullptr, a, vea));
 
   EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, veainf),
+                                         1e6, nullptr, a, veainf),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, veaNaN),
+                                         1e6, nullptr, a, veaNaN),
                std::domain_error);
 }
 
@@ -334,18 +334,18 @@ TEST(ode_adams_tol_prim, rtol_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, rtol, 1e-10,
-                                           1e6, nullptr, a));
+                                            1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, rtol_negative,
-                                        1e-10, 1e6, nullptr, a),
+                                         1e-10, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, rtolinf, 1e-10,
-                                        1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, rtolNaN, 1e-10,
-                                        1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -362,18 +362,18 @@ TEST(ode_adams_tol_prim, atol_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, atol,
-                                           1e6, nullptr, a));
+                                            1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6,
-                                        atol_negative, 1e6, nullptr, a),
+                                         atol_negative, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, atolinf,
-                                        1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, atolNaN,
-                                        1e6, nullptr, a),
+                                         1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -389,14 +389,14 @@ TEST(ode_adams_tol_prim, max_num_steps_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                           max_num_steps, nullptr, a));
+                                            max_num_steps, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                        max_num_steps_negative, nullptr, a),
+                                         max_num_steps_negative, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                        max_num_steps_zero, nullptr, a),
+                                         max_num_steps_zero, nullptr, a),
                std::domain_error);
 }
 
@@ -408,10 +408,10 @@ TEST(ode_adams_tol_prim, rhs_wrong_size_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                           100, nullptr, a));
+                                            100, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArgWrongSize(), y0, t0, ts, 1e-6,
-                                        1e-6, 100, nullptr, a),
+                                         1e-6, 100, nullptr, a),
                std::invalid_argument);
 }
 
@@ -423,6 +423,6 @@ TEST(ode_adams_tol_prim, error_name) {
   double ainf = stan::math::INFTY;
 
   EXPECT_THROW_MSG(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                            100, nullptr, ainf),
+                                             100, nullptr, ainf),
                    std::domain_error, "ode_adams_tol");
 }
diff --git a/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
index 75cf2b0b538..16169962b01 100644
--- a/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
@@ -59,7 +59,7 @@ TEST(StanMathOde_ode_adams_tol, int_t0) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+                                  nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
   EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
@@ -76,7 +76,7 @@ TEST(StanMathOde_ode_adams_tol, int_ts) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+                                  nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
   EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
@@ -93,7 +93,7 @@ TEST(StanMathOde_ode_adams_tol, t0) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+                                  nullptr, a);
 
   output[0][0].grad();
 
@@ -119,7 +119,7 @@ TEST(StanMathOde_ode_adams_tol, ts) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+                                  nullptr, a);
 
   output[0][0].grad();
 
@@ -145,7 +145,7 @@ TEST(StanMathOde_ode_adams_tol, ts_repeat) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+                                  nullptr, a);
 
   output[0][0].grad();
 
@@ -183,8 +183,8 @@ TEST(StanMathOde_ode_adams_tol, scalar_arg) {
 
   var a = 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -203,7 +203,7 @@ TEST(StanMathOde_ode_adams_tol, scalar_arg_multi_time) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+                                  nullptr, a);
 
   output[0](0).grad();
 
@@ -227,8 +227,8 @@ TEST(StanMathOde_ode_adams_tol, std_vector_arg) {
 
   std::vector<var> a = {1.5};
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -246,8 +246,8 @@ TEST(StanMathOde_ode_adams_tol, vector_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, 1> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -265,8 +265,8 @@ TEST(StanMathOde_ode_adams_tol, row_vector_arg) {
   Eigen::Matrix<var, 1, Eigen::Dynamic> a(1);
   a << 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -284,8 +284,8 @@ TEST(StanMathOde_ode_adams_tol, matrix_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a(1, 1);
   a << 1.5;
 
-  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a)[0][0];
 
   output.grad();
 
@@ -303,8 +303,8 @@ TEST(StanMathOde_ode_adams_tol, scalar_std_vector_args) {
   var a0 = 0.75;
   std::vector<var> a1 = {0.75};
 
-  var output = stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a0, a1)[0][0];
+  var output = stan::math::ode_adams_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a0, a1)[0][0];
 
   output.grad();
 
@@ -324,9 +324,8 @@ TEST(StanMathOde_ode_adams_tol, std_vector_std_vector_args) {
   std::vector<var> a1(1, a0);
   std::vector<std::vector<var>> a2(1, a1);
 
-  var output
-    = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-			       nullptr, a2)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a2)[0][0];
 
   output.grad();
 
@@ -346,9 +345,8 @@ TEST(StanMathOde_ode_adams_tol, std_vector_vector_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> a2(1, a1);
 
-  var output
-    = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-			       nullptr, a2)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a2)[0][0];
 
   output.grad();
 
@@ -368,9 +366,8 @@ TEST(StanMathOde_ode_adams_tol, std_vector_row_vector_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> a2(1, a1);
 
-  var output
-    = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-			       nullptr, a2)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a2)[0][0];
 
   output.grad();
 
@@ -390,9 +387,8 @@ TEST(StanMathOde_ode_adams_tol, std_vector_matrix_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> a2(1, a1);
 
-  var output
-    = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-			       nullptr, a2)[0][0];
+  var output = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10,
+                                         1e6, nullptr, a2)[0][0];
 
   output.grad();
 
@@ -449,26 +445,26 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
                     exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)));
   };
 
-  double yT1 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                        nullptr, ad)[0](0);
+  double yT1 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10,
+                                         1e6, nullptr, ad)[0](0);
   check_yT(yT1);
 
   var yT2 = stan::math::ode_adams_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
   var yT3 = stan::math::ode_adams_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
   var yT4 = stan::math::ode_adams_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
@@ -476,14 +472,14 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT5 = stan::math::ode_adams_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
   var yT6 = stan::math::ode_adams_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
@@ -491,7 +487,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT7 = stan::math::ode_adams_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
@@ -499,7 +495,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_ts(ts);
 
   var yT8 = stan::math::ode_adams_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                      nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -508,14 +504,14 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT9 = stan::math::ode_adams_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                      nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
   var yT10 = stan::math::ode_adams_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
+                                       nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
@@ -523,7 +519,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT11 = stan::math::ode_adams_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
+                                       nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
@@ -531,7 +527,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_ts(ts);
 
   var yT12 = stan::math::ode_adams_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
+                                       nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -540,7 +536,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT13 = stan::math::ode_adams_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
+                                       nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
@@ -548,7 +544,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_t0(t0);
 
   var yT14 = stan::math::ode_adams_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
+                                       nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -557,7 +553,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_a(a);
 
   var yT15 = stan::math::ode_adams_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
+                                       nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -566,7 +562,7 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_ts(ts);
 
   var yT16 = stan::math::ode_adams_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
+                                       nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index b58a870bec1..66f2ce1f70d 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -160,13 +160,13 @@ TEST(ode_bdf_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  std::vector<std::vector<double>> vva = { va };
-  std::vector<std::vector<double>> vvainf = { vainf };
-  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+  std::vector<std::vector<double>> vva = {va};
+  std::vector<std::vector<double>> vvainf = {vainf};
+  std::vector<std::vector<double>> vvaNaN = {vaNaN};
 
-  std::vector<Eigen::VectorXd> vea = { ea };
-  std::vector<Eigen::VectorXd> veainf = { eainf };
-  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+  std::vector<Eigen::VectorXd> vea = {ea};
+  std::vector<Eigen::VectorXd> veainf = {eainf};
+  std::vector<Eigen::VectorXd> veaNaN = {eaNaN};
 
   EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a));
 
@@ -229,13 +229,13 @@ TEST(ode_bdf_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  std::vector<std::vector<double>> vva = { va };
-  std::vector<std::vector<double>> vvainf = { vainf };
-  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+  std::vector<std::vector<double>> vva = {va};
+  std::vector<std::vector<double>> vvainf = {vainf};
+  std::vector<std::vector<double>> vvaNaN = {vaNaN};
 
-  std::vector<Eigen::VectorXd> vea = { ea };
-  std::vector<Eigen::VectorXd> veainf = { eainf };
-  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+  std::vector<Eigen::VectorXd> vea = {ea};
+  std::vector<Eigen::VectorXd> veainf = {eainf};
+  std::vector<Eigen::VectorXd> veaNaN = {eaNaN};
 
   EXPECT_NO_THROW(stan::math::ode_bdf(Cos2Arg(), y0, t0, ts, nullptr, a, a));
 
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index 4bf8af11883..bf5ec3933e0 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -314,8 +314,7 @@ TEST(StanMathOde_ode_bdf, std_vector_std_vector_args) {
   std::vector<var> a1(1, a0);
   std::vector<std::vector<var>> a2(1, a1);
 
-  var output
-    = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
 
   output.grad();
 
@@ -335,8 +334,7 @@ TEST(StanMathOde_ode_bdf, std_vector_vector_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> a2(1, a1);
 
-  var output
-    = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
 
   output.grad();
 
@@ -356,8 +354,7 @@ TEST(StanMathOde_ode_bdf, std_vector_row_vector_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> a2(1, a1);
 
-  var output
-    = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
 
   output.grad();
 
@@ -377,8 +374,7 @@ TEST(StanMathOde_ode_bdf, std_vector_matrix_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> a2(1, a1);
 
-  var output
-    = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+  var output = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
 
   output.grad();
 
@@ -408,30 +404,33 @@ TEST(StanMathOde_ode_bdf, arg_combos_test) {
 
   auto check_yT = [&](auto yT) {
     EXPECT_NEAR(stan::math::value_of(yT),
-                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
+                y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   auto check_t0 = [&](var t0) {
     EXPECT_NEAR(
         t0.adj(),
-        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)),
+        1e-5);
   };
 
   auto check_a = [&](var a) {
     EXPECT_NEAR(a.adj(),
-                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
-                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
+                -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                    * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)),
+                1e-5);
   };
 
   auto check_ts = [&](std::vector<var> ts) {
     EXPECT_NEAR(
         ts[0].adj(),
-        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)),
+        1e-5);
   };
 
   auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
-    EXPECT_NEAR(y0(0).adj(),
-                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
+    EXPECT_NEAR(y0(0).adj(), exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)),
+                1e-5);
   };
 
   double yT1 = stan::math::ode_bdf(ayt(), y0d, t0d, tsd, nullptr, ad)[0](0);
diff --git a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
index 85765824ea8..3dabafcaf2e 100644
--- a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
@@ -73,18 +73,18 @@ TEST(ode_bdf_tol_prim, y0_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a));
+                                          1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0inf, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a),
+                                       1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0NaN, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a),
+                                       1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0_empty, t0, ts, 1e-10,
-                                        1e-10, 1e6, nullptr, a),
+                                       1e-10, 1e6, nullptr, a),
                std::invalid_argument);
 }
 
@@ -98,14 +98,14 @@ TEST(ode_bdf_tol_prim, t0_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a));
+                                          1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0inf, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a),
+                                       1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0NaN, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a),
+                                       1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -124,32 +124,32 @@ TEST(ode_bdf_tol_prim, ts_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a));
+                                          1e6, nullptr, a));
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
-                                           1e-10, 1e6, nullptr, a));
+                                          1e-10, 1e6, nullptr, a));
 
-    EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
-                                           1e-10, 1e6, nullptr, a));
+  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
+                                          1e-10, 1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
-                                        1e-10, 1e6, nullptr, a),
+                                       1e-10, 1e6, nullptr, a),
                std::invalid_argument);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_early, 1e-10,
-                                        1e-10, 1e6, nullptr, a),
+                                       1e-10, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_decreasing, 1e-10,
-                                        1e-10, 1e6, nullptr, a),
+                                       1e-10, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, tsinf, 1e-10, 1e-10,
-                                        1e6, nullptr, a),
+                                       1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, tsNaN, 1e-10, 1e-10,
-                                        1e6, nullptr, a),
+                                       1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -173,67 +173,67 @@ TEST(ode_bdf_tol_prim, one_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  std::vector<std::vector<double>> vva = { va };
-  std::vector<std::vector<double>> vvainf = { vainf };
-  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+  std::vector<std::vector<double>> vva = {va};
+  std::vector<std::vector<double>> vvainf = {vainf};
+  std::vector<std::vector<double>> vvaNaN = {vaNaN};
 
-  std::vector<Eigen::VectorXd> vea = { ea };
-  std::vector<Eigen::VectorXd> veainf = { eainf };
-  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+  std::vector<Eigen::VectorXd> vea = {ea};
+  std::vector<Eigen::VectorXd> veainf = {eainf};
+  std::vector<Eigen::VectorXd> veaNaN = {eaNaN};
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a));
+                                          1e6, nullptr, a));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, ainf),
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, ainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, aNaN),
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, aNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, va));
+                                          1e6, nullptr, va));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, vainf),
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, vainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, vaNaN),
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, vaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, ea));
+                                          1e6, nullptr, ea));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, eainf),
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, eainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, eaNaN),
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, eaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, vva));
+                                          1e6, nullptr, vva));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, vvainf),
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, vvainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, vvaNaN),
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, vvaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, vea));
+                                          1e6, nullptr, vea));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, veainf),
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, veainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, veaNaN),
+  EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, veaNaN),
                std::domain_error);
 }
 
@@ -257,67 +257,67 @@ TEST(ode_bdf_tol_prim, two_arg_errors) {
   Eigen::VectorXd eaNaN(1);
   eaNaN << aNaN;
 
-  std::vector<std::vector<double>> vva = { va };
-  std::vector<std::vector<double>> vvainf = { vainf };
-  std::vector<std::vector<double>> vvaNaN = { vaNaN };
+  std::vector<std::vector<double>> vva = {va};
+  std::vector<std::vector<double>> vvainf = {vainf};
+  std::vector<std::vector<double>> vvaNaN = {vaNaN};
 
-  std::vector<Eigen::VectorXd> vea = { ea };
-  std::vector<Eigen::VectorXd> veainf = { eainf };
-  std::vector<Eigen::VectorXd> veaNaN = { eaNaN };
+  std::vector<Eigen::VectorXd> vea = {ea};
+  std::vector<Eigen::VectorXd> veainf = {eainf};
+  std::vector<Eigen::VectorXd> veaNaN = {eaNaN};
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a, a));
+                                          1e6, nullptr, a, a));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, ainf),
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, ainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, aNaN),
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, aNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a, va));
+                                          1e6, nullptr, a, va));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, vainf),
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, vainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, vaNaN),
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, vaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a, ea));
+                                          1e6, nullptr, a, ea));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, eainf),
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, eainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, eaNaN),
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, eaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a, vva));
+                                          1e6, nullptr, a, vva));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, vvainf),
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, vvainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, vvaNaN),
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, vvaNaN),
                std::domain_error);
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a, vea));
+                                          1e6, nullptr, a, vea));
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, veainf),
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, veainf),
                std::domain_error);
 
-  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10,
-                                        1e6, nullptr, a, veaNaN),
+  EXPECT_THROW(stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-10, 1e-10, 1e6,
+                                       nullptr, a, veaNaN),
                std::domain_error);
 }
 
@@ -334,18 +334,18 @@ TEST(ode_bdf_tol_prim, rtol_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtol, 1e-10,
-                                           1e6, nullptr, a));
+                                          1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtol_negative,
-                                        1e-10, 1e6, nullptr, a),
+                                       1e-10, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtolinf, 1e-10,
-                                        1e6, nullptr, a),
+                                       1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, rtolNaN, 1e-10,
-                                        1e6, nullptr, a),
+                                       1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -362,18 +362,18 @@ TEST(ode_bdf_tol_prim, atol_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atol,
-                                           1e6, nullptr, a));
+                                          1e6, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6,
-                                        atol_negative, 1e6, nullptr, a),
+                                       atol_negative, 1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atolinf,
-                                        1e6, nullptr, a),
+                                       1e6, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, atolNaN,
-                                        1e6, nullptr, a),
+                                       1e6, nullptr, a),
                std::domain_error);
 }
 
@@ -389,14 +389,14 @@ TEST(ode_bdf_tol_prim, max_num_steps_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                           max_num_steps, nullptr, a));
+                                          max_num_steps, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                        max_num_steps_negative, nullptr, a),
+                                       max_num_steps_negative, nullptr, a),
                std::domain_error);
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                        max_num_steps_zero, nullptr, a),
+                                       max_num_steps_zero, nullptr, a),
                std::domain_error);
 }
 
@@ -408,10 +408,10 @@ TEST(ode_bdf_tol_prim, rhs_wrong_size_errors) {
   double a = 1.5;
 
   EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                           100, nullptr, a));
+                                          100, nullptr, a));
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArgWrongSize(), y0, t0, ts, 1e-6,
-                                        1e-6, 100, nullptr, a),
+                                       1e-6, 100, nullptr, a),
                std::invalid_argument);
 }
 
@@ -423,6 +423,6 @@ TEST(ode_bdf_tol_prim, error_name) {
   double ainf = stan::math::INFTY;
 
   EXPECT_THROW_MSG(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-                                            100, nullptr, ainf),
+                                           100, nullptr, ainf),
                    std::domain_error, "ode_bdf_tol");
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
index 672582e8490..da2e9cbbf20 100644
--- a/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
@@ -59,7 +59,7 @@ TEST(StanMathOde_ode_bdf_tol, int_t0) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+                                nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.4165982112);
   EXPECT_FLOAT_EQ(output[1][0], 0.66457668563);
@@ -76,7 +76,7 @@ TEST(StanMathOde_ode_bdf_tol, int_ts) {
 
   std::vector<Eigen::Matrix<double, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+                                nullptr, a);
 
   EXPECT_FLOAT_EQ(output[0][0], 0.6649966577);
   EXPECT_FLOAT_EQ(output[1][0], 0.09408000537);
@@ -93,7 +93,7 @@ TEST(StanMathOde_ode_bdf_tol, t0) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+                                nullptr, a);
 
   output[0][0].grad();
 
@@ -119,7 +119,7 @@ TEST(StanMathOde_ode_bdf_tol, ts) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+                                nullptr, a);
 
   output[0][0].grad();
 
@@ -145,7 +145,7 @@ TEST(StanMathOde_ode_bdf_tol, ts_repeat) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+                                nullptr, a);
 
   output[0][0].grad();
 
@@ -184,7 +184,7 @@ TEST(StanMathOde_ode_bdf_tol, scalar_arg) {
   var a = 1.5;
 
   var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0][0];
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -203,7 +203,7 @@ TEST(StanMathOde_ode_bdf_tol, scalar_arg_multi_time) {
 
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                 nullptr, a);
+                                nullptr, a);
 
   output[0](0).grad();
 
@@ -228,7 +228,7 @@ TEST(StanMathOde_ode_bdf_tol, std_vector_arg) {
   std::vector<var> a = {1.5};
 
   var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0][0];
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -247,7 +247,7 @@ TEST(StanMathOde_ode_bdf_tol, vector_arg) {
   a << 1.5;
 
   var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0][0];
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -266,7 +266,7 @@ TEST(StanMathOde_ode_bdf_tol, row_vector_arg) {
   a << 1.5;
 
   var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0][0];
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -285,7 +285,7 @@ TEST(StanMathOde_ode_bdf_tol, matrix_arg) {
   a << 1.5;
 
   var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a)[0][0];
+                                       nullptr, a)[0][0];
 
   output.grad();
 
@@ -304,7 +304,7 @@ TEST(StanMathOde_ode_bdf_tol, scalar_std_vector_args) {
   std::vector<var> a1 = {0.75};
 
   var output = stan::math::ode_bdf_tol(Cos2Arg(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-                                        nullptr, a0, a1)[0][0];
+                                       nullptr, a0, a1)[0][0];
 
   output.grad();
 
@@ -324,9 +324,8 @@ TEST(StanMathOde_ode_bdf_tol, std_vector_std_vector_args) {
   std::vector<var> a1(1, a0);
   std::vector<std::vector<var>> a2(1, a1);
 
-  var output
-    = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-			       nullptr, a2)[0][0];
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a2)[0][0];
 
   output.grad();
 
@@ -346,9 +345,8 @@ TEST(StanMathOde_ode_bdf_tol, std_vector_vector_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> a2(1, a1);
 
-  var output
-    = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-			       nullptr, a2)[0][0];
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a2)[0][0];
 
   output.grad();
 
@@ -368,9 +366,8 @@ TEST(StanMathOde_ode_bdf_tol, std_vector_row_vector_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> a2(1, a1);
 
-  var output
-    = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-			       nullptr, a2)[0][0];
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a2)[0][0];
 
   output.grad();
 
@@ -390,9 +387,8 @@ TEST(StanMathOde_ode_bdf_tol, std_vector_matrix_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> a2(1, a1);
 
-  var output
-    = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-			       nullptr, a2)[0][0];
+  var output = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                       nullptr, a2)[0][0];
 
   output.grad();
 
@@ -450,25 +446,25 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   };
 
   double yT1 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                        nullptr, ad)[0](0);
+                                       nullptr, ad)[0](0);
   check_yT(yT1);
 
   var yT2 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                    nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT2.grad();
   check_yT(yT2);
   check_a(a);
 
   var yT3 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                    nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT3.grad();
   check_yT(yT3);
   check_ts(ts);
 
   var yT4 = stan::math::ode_bdf_tol(ayt(), y0d, t0d, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                    nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT4.grad();
   check_yT(yT4);
@@ -476,14 +472,14 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_a(a);
 
   var yT5 = stan::math::ode_bdf_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                    nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT5.grad();
   check_yT(yT5);
   check_t0(t0);
 
   var yT6 = stan::math::ode_bdf_tol(ayt(), y0d, t0, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                    nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT6.grad();
   check_yT(yT6);
@@ -491,7 +487,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_a(a);
 
   var yT7 = stan::math::ode_bdf_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                    nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT7.grad();
   check_yT(yT7);
@@ -499,7 +495,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_ts(ts);
 
   var yT8 = stan::math::ode_bdf_tol(ayt(), y0d, t0, ts, 1e-10, 1e-10, 1e6,
-                                     nullptr, a)[0](0);
+                                    nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT8.grad();
   check_yT(yT8);
@@ -508,14 +504,14 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_a(a);
 
   var yT9 = stan::math::ode_bdf_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                     nullptr, ad)[0](0);
+                                    nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT9.grad();
   check_yT(yT9);
   check_y0(y0);
 
   var yT10 = stan::math::ode_bdf_tol(ayt(), y0, t0d, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT10.grad();
   check_yT(yT10);
@@ -523,7 +519,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_a(a);
 
   var yT11 = stan::math::ode_bdf_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT11.grad();
   check_yT(yT11);
@@ -531,7 +527,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_ts(ts);
 
   var yT12 = stan::math::ode_bdf_tol(ayt(), y0, t0d, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT12.grad();
   check_yT(yT12);
@@ -540,7 +536,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_a(a);
 
   var yT13 = stan::math::ode_bdf_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT13.grad();
   check_yT(yT13);
@@ -548,7 +544,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_t0(t0);
 
   var yT14 = stan::math::ode_bdf_tol(ayt(), y0, t0, tsd, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT14.grad();
   check_yT(yT14);
@@ -557,7 +553,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_a(a);
 
   var yT15 = stan::math::ode_bdf_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, ad)[0](0);
+                                     nullptr, ad)[0](0);
   stan::math::set_zero_all_adjoints();
   yT15.grad();
   check_yT(yT15);
@@ -566,7 +562,7 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_ts(ts);
 
   var yT16 = stan::math::ode_bdf_tol(ayt(), y0, t0, ts, 1e-10, 1e-10, 1e6,
-                                      nullptr, a)[0](0);
+                                     nullptr, a)[0](0);
   stan::math::set_zero_all_adjoints();
   yT16.grad();
   check_yT(yT16);
diff --git a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
index 4a2ac8172fb..50d3cffdf67 100644
--- a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
@@ -314,8 +314,7 @@ TEST(StanMathOde_ode_rk45, std_vector_std_vector_args) {
   std::vector<var> a1(1, a0);
   std::vector<std::vector<var>> a2(1, a1);
 
-  var output
-      = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
 
   output.grad();
 
@@ -335,8 +334,7 @@ TEST(StanMathOde_ode_rk45, std_vector_vector_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> a2(1, a1);
 
-  var output
-      = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
 
   output.grad();
 
@@ -356,8 +354,7 @@ TEST(StanMathOde_ode_rk45, std_vector_row_vector_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> a2(1, a1);
 
-  var output
-      = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
 
   output.grad();
 
@@ -377,8 +374,7 @@ TEST(StanMathOde_ode_rk45, std_vector_matrix_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> a2(1, a1);
 
-  var output
-      = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
+  var output = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a2)[0][0];
 
   output.grad();
 
@@ -408,30 +404,33 @@ TEST(StanMathOde_ode_rk45, arg_combos_test) {
 
   auto check_yT = [&](auto yT) {
     EXPECT_NEAR(stan::math::value_of(yT),
-                    y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
+                y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
   };
 
   auto check_t0 = [&](var t0) {
     EXPECT_NEAR(
         t0.adj(),
-        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
+        ad * t0d * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)),
+        1e-5);
   };
 
   auto check_a = [&](var a) {
     EXPECT_NEAR(a.adj(),
-                    -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
-                        * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
+                -0.5 * (tsd[0] * tsd[0] - t0d * t0d) * y0d(0)
+                    * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)),
+                1e-5);
   };
 
   auto check_ts = [&](std::vector<var> ts) {
     EXPECT_NEAR(
         ts[0].adj(),
-        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
+        -ad * tsd[0] * y0d(0) * exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)),
+        1e-5);
   };
 
   auto check_y0 = [&](Eigen::Matrix<var, Eigen::Dynamic, 1> y0) {
-    EXPECT_NEAR(y0(0).adj(),
-                    exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)), 1e-5);
+    EXPECT_NEAR(y0(0).adj(), exp(-0.5 * ad * (tsd[0] * tsd[0] - t0d * t0d)),
+                1e-5);
   };
 
   double yT1 = stan::math::ode_rk45(ayt(), y0d, t0d, tsd, nullptr, ad)[0](0);
diff --git a/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
index 8ce515ed0f8..b678e34c623 100644
--- a/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
@@ -324,9 +324,8 @@ TEST(StanMathOde_ode_rk45_tol, std_vector_std_vector_args) {
   std::vector<var> a1(1, a0);
   std::vector<std::vector<var>> a2(1, a1);
 
-  var output
-    = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-			       nullptr, a2)[0][0];
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a2)[0][0];
 
   output.grad();
 
@@ -346,9 +345,8 @@ TEST(StanMathOde_ode_rk45_tol, std_vector_vector_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> a2(1, a1);
 
-  var output
-    = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-			       nullptr, a2)[0][0];
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a2)[0][0];
 
   output.grad();
 
@@ -368,9 +366,8 @@ TEST(StanMathOde_ode_rk45_tol, std_vector_row_vector_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> a2(1, a1);
 
-  var output
-    = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-			       nullptr, a2)[0][0];
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a2)[0][0];
 
   output.grad();
 
@@ -390,9 +387,8 @@ TEST(StanMathOde_ode_rk45_tol, std_vector_matrix_args) {
   a1 << a0;
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> a2(1, a1);
 
-  var output
-    = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
-			       nullptr, a2)[0][0];
+  var output = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-8, 1e-10, 1e6,
+                                        nullptr, a2)[0][0];
 
   output.grad();
 

From b76e7a5a5c866a8d20379d91dcbf117d79a0c92c Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Fri, 3 Jul 2020 13:54:27 -0400
Subject: [PATCH 154/189] Made zero_adjoints its own standalone function
 (design-doc #19)

---
 stan/math/rev/core.hpp                        |   1 +
 stan/math/rev/core/zero_adjoints.hpp          |  97 ++++++++
 stan/math/rev/functor/coupled_ode_system.hpp  |  27 ---
 .../unit/math/rev/core/zero_adjoints_test.cpp | 223 ++++++++++++++++++
 4 files changed, 321 insertions(+), 27 deletions(-)
 create mode 100644 stan/math/rev/core/zero_adjoints.hpp
 create mode 100644 test/unit/math/rev/core/zero_adjoints_test.cpp

diff --git a/stan/math/rev/core.hpp b/stan/math/rev/core.hpp
index 33eb934c08e..7ff988c98f0 100644
--- a/stan/math/rev/core.hpp
+++ b/stan/math/rev/core.hpp
@@ -67,5 +67,6 @@
 #include <stan/math/rev/core/vvd_vari.hpp>
 #include <stan/math/rev/core/vvv_vari.hpp>
 #include <stan/math/rev/core/save_varis.hpp>
+#include <stan/math/rev/core/zero_adjoints.hpp>
 
 #endif
diff --git a/stan/math/rev/core/zero_adjoints.hpp b/stan/math/rev/core/zero_adjoints.hpp
new file mode 100644
index 00000000000..ecbf7389146
--- /dev/null
+++ b/stan/math/rev/core/zero_adjoints.hpp
@@ -0,0 +1,97 @@
+#ifndef STAN_MATH_REV_CORE_ZERO_ADJOINTS_HPP
+#define STAN_MATH_REV_CORE_ZERO_ADJOINTS_HPP
+
+#include <stan/math/rev/core/vari.hpp>
+#include <stan/math/rev/core/chainable_alloc.hpp>
+#include <stan/math/rev/core/chainablestack.hpp>
+
+namespace stan {
+namespace math {
+
+inline void zero_adjoints();
+
+template <typename T, typename... Pargs>
+inline void zero_adjoints(T& x, Pargs&... args);
+
+template <typename... Pargs>
+inline void zero_adjoints(var& x, Pargs&... args);
+
+template <int R, int C, typename... Pargs>
+inline void zero_adjoints(Eigen::Matrix<var, R, C>& x, Pargs&... args);
+
+template <typename T, typename... Pargs>
+inline void zero_adjoints(std::vector<T>& x, Pargs&... args);
+
+/**
+ * End of recursion for set_zero_adjoints
+ */
+inline void zero_adjoints() {}
+
+/**
+ * Do nothing for non-autodiff arguments. Recursively call zero_adjoints
+ * on the rest of the arguments.
+ *
+ * @tparam T type of current argument
+ * @tparam Pargs type of rest of arguments
+ *
+ * @param x current argument
+ * @param args rest of arguments to zero
+ */
+template <typename T, typename... Pargs>
+inline void zero_adjoints(T& x, Pargs&... args) {
+  zero_adjoints(args...);
+}
+
+/**
+ * Zero the adjoint of the vari in the first argument. Recursively call
+ * zero_adjoints on the rest of the arguments.
+ *
+ * @tparam T type of current argument
+ * @tparam Pargs type of rest of arguments
+ *
+ * @param x current argument
+ * @param args rest of arguments to zero
+ */
+template <typename... Pargs>
+inline void zero_adjoints(var& x, Pargs&... args) {
+  x.vi_->set_zero_adjoint();
+  zero_adjoints(args...);
+}
+
+/**
+ * Zero the adjoints of the varis of every var in an Eigen::Matrix
+ * container. Recursively call zero_adjoints on the rest of the arguments.
+ *
+ * @tparam T type of current argument
+ * @tparam Pargs type of rest of arguments
+ *
+ * @param x current argument
+ * @param args rest of arguments to zero
+ */
+template <int R, int C, typename... Pargs>
+inline void zero_adjoints(Eigen::Matrix<var, R, C>& x, Pargs&... args) {
+  for (size_t i = 0; i < x.size(); ++i)
+    x.coeffRef(i).vi_->set_zero_adjoint();
+  zero_adjoints(args...);
+}
+
+/**
+ * Zero the adjoints of every element in a vector. Recursively call
+ * zero_adjoints on the rest of the arguments.
+ *
+ * @tparam T type of current argument
+ * @tparam Pargs type of rest of arguments
+ *
+ * @param x current argument
+ * @param args rest of arguments to zero
+ */
+template <typename T, typename... Pargs>
+inline void zero_adjoints(std::vector<T>& x, Pargs&... args) {
+  for (size_t i = 0; i < x.size(); ++i)
+    zero_adjoints(x[i]);
+  zero_adjoints(args...);
+}
+
+}  // namespace math
+}  // namespace stan
+#endif
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index c36fa6109fa..6cc03fc55e5 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -99,33 +99,6 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
         y_adjoints_(N_),
         msgs_(msgs) {}
 
-  inline void zero_adjoints() {}
-
-  template <typename T, typename... Pargs>
-  inline void zero_adjoints(T& x, Pargs&... args) {
-    zero_adjoints(args...);
-  }
-
-  template <typename... Pargs>
-  inline void zero_adjoints(var& x, Pargs&... args) {
-    x.vi_->set_zero_adjoint();
-    zero_adjoints(args...);
-  }
-
-  template <typename T, typename... Pargs>
-  inline void zero_adjoints(std::vector<T>& x, Pargs&... args) {
-    for (size_t i = 0; i < x.size(); ++i)
-      zero_adjoints(x[i]);
-    zero_adjoints(args...);
-  }
-
-  template <int R, int C, typename... Pargs>
-  inline void zero_adjoints(Eigen::Matrix<var, R, C>& x, Pargs&... args) {
-    for (size_t i = 0; i < x.size(); ++i)
-      x.coeffRef(i).vi_->set_zero_adjoint();
-    zero_adjoints(args...);
-  }
-
   /**
    * Calculates the right hand side of the coupled ode system (the regular
    * ode system with forward sensitivities).
diff --git a/test/unit/math/rev/core/zero_adjoints_test.cpp b/test/unit/math/rev/core/zero_adjoints_test.cpp
new file mode 100644
index 00000000000..0a9d9354374
--- /dev/null
+++ b/test/unit/math/rev/core/zero_adjoints_test.cpp
@@ -0,0 +1,223 @@
+#include <gtest/gtest.h>
+#include <test/unit/math/rev/fun/util.hpp>
+#include <stan/math/rev/core.hpp>
+#include <stan/math/rev/fun/sin.hpp>
+#include <vector>
+
+TEST(AgradRev, zero_arithmetic) {
+  int a = 1.0;
+  double b = 2;
+  std::vector<int> va(5, a);
+  std::vector<double> vb(5, b);
+  Eigen::VectorXd c = Eigen::VectorXd::Random(5);
+  Eigen::RowVectorXd d = Eigen::RowVectorXd::Random(5);
+  Eigen::MatrixXd e = Eigen::MatrixXd::Random(5, 5);
+  std::vector<std::vector<int>> vva(5, va);
+  std::vector<std::vector<double>> vvb(5, vb);
+  std::vector<Eigen::VectorXd> vc(5, c);
+  std::vector<Eigen::RowVectorXd> vd(5, d);
+  std::vector<Eigen::MatrixXd> ve(5, e);
+
+  stan::math::zero_adjoints(a);
+  stan::math::zero_adjoints(b);
+  stan::math::zero_adjoints(va);
+  stan::math::zero_adjoints(vb);
+  stan::math::zero_adjoints(c);
+  stan::math::zero_adjoints(d);
+  stan::math::zero_adjoints(e);
+  stan::math::zero_adjoints(vva);
+  stan::math::zero_adjoints(vvb);
+  stan::math::zero_adjoints(vc);
+  stan::math::zero_adjoints(vd);
+  stan::math::zero_adjoints(ve);
+
+  stan::math::zero_adjoints(a, b, va, vb, c, d, e,
+		vva, vvb, vc, vd, ve);
+}
+
+TEST(AgradRev, zero_var) {
+  using stan::math::var;
+  using stan::math::vari;
+
+  var a(5.0);
+  a.vi_->adj_ = 2.0;
+
+  stan::math::zero_adjoints(a);
+  EXPECT_FLOAT_EQ(a.vi_->adj_, 0.0);
+
+  stan::math::recover_memory();
+}
+
+TEST(AgradRev, zero_std_vector_var) {
+  using stan::math::var;
+  using stan::math::vari;
+
+  std::vector<var> a(5, 0.0);
+  for(size_t i = 0; i < a.size(); ++i)
+    a[i].vi_->adj_ = i + 1.0;
+
+  stan::math::zero_adjoints(a);
+  for(size_t i = 0; i < a.size(); ++i)
+    EXPECT_FLOAT_EQ(a[i].vi_->adj_, 0.0);
+
+  stan::math::recover_memory();
+}
+
+TEST(AgradRev, zero_vector_var) {
+  using stan::math::var;
+  using stan::math::vari;
+
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a =
+    Eigen::VectorXd::Zero(5).template cast<var>();
+  for(size_t i = 0; i < a.size(); ++i)
+    a(i).vi_->adj_ = i + 1.0;
+
+  stan::math::zero_adjoints(a);
+  for(size_t i = 0; i < a.size(); ++i)
+    EXPECT_FLOAT_EQ(a(i).vi_->adj_, 0.0);
+
+  stan::math::recover_memory();
+}
+
+TEST(AgradRev, zero_row_vector_var) {
+  using stan::math::var;
+  using stan::math::vari;
+
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a =
+    Eigen::RowVectorXd::Zero(5).template cast<var>();
+  for(size_t i = 0; i < a.size(); ++i)
+    a(i).vi_->adj_ = i + 1.0;
+
+  stan::math::zero_adjoints(a);
+  for(size_t i = 0; i < a.size(); ++i)
+    EXPECT_FLOAT_EQ(a(i).vi_->adj_, 0.0);
+
+  stan::math::recover_memory();
+}
+
+TEST(AgradRev, zero_matrix_var) {
+  using stan::math::var;
+  using stan::math::vari;
+
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a =
+    Eigen::MatrixXd::Zero(5, 5).template cast<var>();
+  for(size_t i = 0; i < a.size(); ++i)
+    a(i).vi_->adj_ = i + 1.0;
+
+  stan::math::zero_adjoints(a);
+  for(size_t i = 0; i < a.size(); ++i)
+    EXPECT_FLOAT_EQ(a(i).vi_->adj_, 0.0);
+
+  stan::math::recover_memory();
+}
+
+TEST(AgradRev, zero_std_vector_std_vector_var) {
+  using stan::math::var;
+  using stan::math::vari;
+
+  std::vector<var> a(5, 0.0);
+  std::vector<var> b(5, 1.0);
+  std::vector<var> c(5, 2.0);
+  std::vector<std::vector<var>> va = { a, b, c };
+  for(size_t i = 0; i < va.size(); ++i)
+    for(size_t j = 0; j < va[i].size(); ++j)
+      va[i][j].vi_->adj_ = i + 1.0;
+
+  stan::math::zero_adjoints(va);
+  for(size_t i = 0; i < va.size(); ++i)
+    for(size_t j = 0; j < va[i].size(); ++j)
+      EXPECT_FLOAT_EQ(va[i][j].vi_->adj_, 0.0);
+
+  stan::math::recover_memory();
+}
+
+TEST(AgradRev, zero_std_vector_vector_var) {
+  using stan::math::var;
+  using stan::math::vari;
+
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a =
+    Eigen::VectorXd::Zero(3).template cast<var>();
+  Eigen::Matrix<var, Eigen::Dynamic, 1> b =
+    Eigen::VectorXd::Zero(4).template cast<var>();
+  Eigen::Matrix<var, Eigen::Dynamic, 1> c =
+    Eigen::VectorXd::Zero(5).template cast<var>();
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> va = { a, b, c };
+  for(size_t i = 0; i < va.size(); ++i)
+    for(size_t j = 0; j < va[i].size(); ++j)
+      va[i](j).vi_->adj_ = i + 1.0;
+
+  stan::math::zero_adjoints(va);
+  for(size_t i = 0; i < va.size(); ++i)
+    for(size_t j = 0; j < va[i].size(); ++j)
+      EXPECT_FLOAT_EQ(va[i](j).vi_->adj_, 0.0);
+
+  stan::math::recover_memory();
+}
+
+TEST(AgradRev, zero_std_vector_row_vector_var) {
+  using stan::math::var;
+  using stan::math::vari;
+
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a =
+    Eigen::RowVectorXd::Zero(3).template cast<var>();
+  Eigen::Matrix<var, 1, Eigen::Dynamic> b =
+    Eigen::RowVectorXd::Zero(4).template cast<var>();
+  Eigen::Matrix<var, 1, Eigen::Dynamic> c =
+    Eigen::RowVectorXd::Zero(5).template cast<var>();
+  std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> va = { a, b, c };
+  for(size_t i = 0; i < va.size(); ++i)
+    for(size_t j = 0; j < va[i].size(); ++j)
+      va[i](j).vi_->adj_ = i + 1.0;
+
+  stan::math::zero_adjoints(va);
+  for(size_t i = 0; i < va.size(); ++i)
+    for(size_t j = 0; j < va[i].size(); ++j)
+      EXPECT_FLOAT_EQ(va[i](j).vi_->adj_, 0.0);
+
+  stan::math::recover_memory();
+}
+
+TEST(AgradRev, zero_std_vector_matrix_var) {
+  using stan::math::var;
+  using stan::math::vari;
+
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a =
+    Eigen::MatrixXd::Zero(3, 4).template cast<var>();
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> b =
+    Eigen::MatrixXd::Zero(4, 5).template cast<var>();
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> c =
+    Eigen::MatrixXd::Zero(5, 6).template cast<var>();
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> va = { a, b, c };
+  for(size_t i = 0; i < va.size(); ++i)
+    for(size_t j = 0; j < va[i].size(); ++j)
+      va[i](j).vi_->adj_ = i + 1.0;
+
+  stan::math::zero_adjoints(va);
+  for(size_t i = 0; i < va.size(); ++i)
+    for(size_t j = 0; j < va[i].size(); ++j)
+      EXPECT_FLOAT_EQ(va[i](j).vi_->adj_, 0.0);
+
+  stan::math::recover_memory();
+}
+
+TEST(AgradRev, zero_multi) {
+  using stan::math::var;
+  using stan::math::vari;
+
+  int a = 2;
+  double b = 3;
+  var c(5.0);
+  c.vi_->adj_ = 2.0;
+  std::vector<var> d(5, 1.0);
+  for(size_t i = 0; i < d.size(); ++i)
+    d[i].vi_->adj_ = i + 1.0;
+  std::vector<int> e(5, 1);
+  std::vector<double> f(5, 1.0);
+
+  stan::math::zero_adjoints(a, b, c, d, e, f);
+  EXPECT_FLOAT_EQ(c.vi_->adj_, 0.0);
+  for(size_t i = 0; i < d.size(); ++i)
+    EXPECT_FLOAT_EQ(d[i].vi_->adj_, 0.0);
+
+  stan::math::recover_memory();
+}

From ce1377aeae92926dd840a7ba0f987393ab77166c Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 3 Jul 2020 15:04:54 -0400
Subject: [PATCH 155/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 .../unit/math/rev/core/zero_adjoints_test.cpp | 112 +++++++++---------
 1 file changed, 56 insertions(+), 56 deletions(-)

diff --git a/test/unit/math/rev/core/zero_adjoints_test.cpp b/test/unit/math/rev/core/zero_adjoints_test.cpp
index 0a9d9354374..07ab008e47b 100644
--- a/test/unit/math/rev/core/zero_adjoints_test.cpp
+++ b/test/unit/math/rev/core/zero_adjoints_test.cpp
@@ -31,8 +31,7 @@ TEST(AgradRev, zero_arithmetic) {
   stan::math::zero_adjoints(vd);
   stan::math::zero_adjoints(ve);
 
-  stan::math::zero_adjoints(a, b, va, vb, c, d, e,
-		vva, vvb, vc, vd, ve);
+  stan::math::zero_adjoints(a, b, va, vb, c, d, e, vva, vvb, vc, vd, ve);
 }
 
 TEST(AgradRev, zero_var) {
@@ -53,11 +52,11 @@ TEST(AgradRev, zero_std_vector_var) {
   using stan::math::vari;
 
   std::vector<var> a(5, 0.0);
-  for(size_t i = 0; i < a.size(); ++i)
+  for (size_t i = 0; i < a.size(); ++i)
     a[i].vi_->adj_ = i + 1.0;
 
   stan::math::zero_adjoints(a);
-  for(size_t i = 0; i < a.size(); ++i)
+  for (size_t i = 0; i < a.size(); ++i)
     EXPECT_FLOAT_EQ(a[i].vi_->adj_, 0.0);
 
   stan::math::recover_memory();
@@ -67,13 +66,13 @@ TEST(AgradRev, zero_vector_var) {
   using stan::math::var;
   using stan::math::vari;
 
-  Eigen::Matrix<var, Eigen::Dynamic, 1> a =
-    Eigen::VectorXd::Zero(5).template cast<var>();
-  for(size_t i = 0; i < a.size(); ++i)
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a
+      = Eigen::VectorXd::Zero(5).template cast<var>();
+  for (size_t i = 0; i < a.size(); ++i)
     a(i).vi_->adj_ = i + 1.0;
 
   stan::math::zero_adjoints(a);
-  for(size_t i = 0; i < a.size(); ++i)
+  for (size_t i = 0; i < a.size(); ++i)
     EXPECT_FLOAT_EQ(a(i).vi_->adj_, 0.0);
 
   stan::math::recover_memory();
@@ -83,13 +82,13 @@ TEST(AgradRev, zero_row_vector_var) {
   using stan::math::var;
   using stan::math::vari;
 
-  Eigen::Matrix<var, 1, Eigen::Dynamic> a =
-    Eigen::RowVectorXd::Zero(5).template cast<var>();
-  for(size_t i = 0; i < a.size(); ++i)
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a
+      = Eigen::RowVectorXd::Zero(5).template cast<var>();
+  for (size_t i = 0; i < a.size(); ++i)
     a(i).vi_->adj_ = i + 1.0;
 
   stan::math::zero_adjoints(a);
-  for(size_t i = 0; i < a.size(); ++i)
+  for (size_t i = 0; i < a.size(); ++i)
     EXPECT_FLOAT_EQ(a(i).vi_->adj_, 0.0);
 
   stan::math::recover_memory();
@@ -99,13 +98,13 @@ TEST(AgradRev, zero_matrix_var) {
   using stan::math::var;
   using stan::math::vari;
 
-  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a =
-    Eigen::MatrixXd::Zero(5, 5).template cast<var>();
-  for(size_t i = 0; i < a.size(); ++i)
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a
+      = Eigen::MatrixXd::Zero(5, 5).template cast<var>();
+  for (size_t i = 0; i < a.size(); ++i)
     a(i).vi_->adj_ = i + 1.0;
 
   stan::math::zero_adjoints(a);
-  for(size_t i = 0; i < a.size(); ++i)
+  for (size_t i = 0; i < a.size(); ++i)
     EXPECT_FLOAT_EQ(a(i).vi_->adj_, 0.0);
 
   stan::math::recover_memory();
@@ -118,14 +117,14 @@ TEST(AgradRev, zero_std_vector_std_vector_var) {
   std::vector<var> a(5, 0.0);
   std::vector<var> b(5, 1.0);
   std::vector<var> c(5, 2.0);
-  std::vector<std::vector<var>> va = { a, b, c };
-  for(size_t i = 0; i < va.size(); ++i)
-    for(size_t j = 0; j < va[i].size(); ++j)
+  std::vector<std::vector<var>> va = {a, b, c};
+  for (size_t i = 0; i < va.size(); ++i)
+    for (size_t j = 0; j < va[i].size(); ++j)
       va[i][j].vi_->adj_ = i + 1.0;
 
   stan::math::zero_adjoints(va);
-  for(size_t i = 0; i < va.size(); ++i)
-    for(size_t j = 0; j < va[i].size(); ++j)
+  for (size_t i = 0; i < va.size(); ++i)
+    for (size_t j = 0; j < va[i].size(); ++j)
       EXPECT_FLOAT_EQ(va[i][j].vi_->adj_, 0.0);
 
   stan::math::recover_memory();
@@ -135,20 +134,20 @@ TEST(AgradRev, zero_std_vector_vector_var) {
   using stan::math::var;
   using stan::math::vari;
 
-  Eigen::Matrix<var, Eigen::Dynamic, 1> a =
-    Eigen::VectorXd::Zero(3).template cast<var>();
-  Eigen::Matrix<var, Eigen::Dynamic, 1> b =
-    Eigen::VectorXd::Zero(4).template cast<var>();
-  Eigen::Matrix<var, Eigen::Dynamic, 1> c =
-    Eigen::VectorXd::Zero(5).template cast<var>();
-  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> va = { a, b, c };
-  for(size_t i = 0; i < va.size(); ++i)
-    for(size_t j = 0; j < va[i].size(); ++j)
+  Eigen::Matrix<var, Eigen::Dynamic, 1> a
+      = Eigen::VectorXd::Zero(3).template cast<var>();
+  Eigen::Matrix<var, Eigen::Dynamic, 1> b
+      = Eigen::VectorXd::Zero(4).template cast<var>();
+  Eigen::Matrix<var, Eigen::Dynamic, 1> c
+      = Eigen::VectorXd::Zero(5).template cast<var>();
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> va = {a, b, c};
+  for (size_t i = 0; i < va.size(); ++i)
+    for (size_t j = 0; j < va[i].size(); ++j)
       va[i](j).vi_->adj_ = i + 1.0;
 
   stan::math::zero_adjoints(va);
-  for(size_t i = 0; i < va.size(); ++i)
-    for(size_t j = 0; j < va[i].size(); ++j)
+  for (size_t i = 0; i < va.size(); ++i)
+    for (size_t j = 0; j < va[i].size(); ++j)
       EXPECT_FLOAT_EQ(va[i](j).vi_->adj_, 0.0);
 
   stan::math::recover_memory();
@@ -158,20 +157,20 @@ TEST(AgradRev, zero_std_vector_row_vector_var) {
   using stan::math::var;
   using stan::math::vari;
 
-  Eigen::Matrix<var, 1, Eigen::Dynamic> a =
-    Eigen::RowVectorXd::Zero(3).template cast<var>();
-  Eigen::Matrix<var, 1, Eigen::Dynamic> b =
-    Eigen::RowVectorXd::Zero(4).template cast<var>();
-  Eigen::Matrix<var, 1, Eigen::Dynamic> c =
-    Eigen::RowVectorXd::Zero(5).template cast<var>();
-  std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> va = { a, b, c };
-  for(size_t i = 0; i < va.size(); ++i)
-    for(size_t j = 0; j < va[i].size(); ++j)
+  Eigen::Matrix<var, 1, Eigen::Dynamic> a
+      = Eigen::RowVectorXd::Zero(3).template cast<var>();
+  Eigen::Matrix<var, 1, Eigen::Dynamic> b
+      = Eigen::RowVectorXd::Zero(4).template cast<var>();
+  Eigen::Matrix<var, 1, Eigen::Dynamic> c
+      = Eigen::RowVectorXd::Zero(5).template cast<var>();
+  std::vector<Eigen::Matrix<var, 1, Eigen::Dynamic>> va = {a, b, c};
+  for (size_t i = 0; i < va.size(); ++i)
+    for (size_t j = 0; j < va[i].size(); ++j)
       va[i](j).vi_->adj_ = i + 1.0;
 
   stan::math::zero_adjoints(va);
-  for(size_t i = 0; i < va.size(); ++i)
-    for(size_t j = 0; j < va[i].size(); ++j)
+  for (size_t i = 0; i < va.size(); ++i)
+    for (size_t j = 0; j < va[i].size(); ++j)
       EXPECT_FLOAT_EQ(va[i](j).vi_->adj_, 0.0);
 
   stan::math::recover_memory();
@@ -181,20 +180,21 @@ TEST(AgradRev, zero_std_vector_matrix_var) {
   using stan::math::var;
   using stan::math::vari;
 
-  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a =
-    Eigen::MatrixXd::Zero(3, 4).template cast<var>();
-  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> b =
-    Eigen::MatrixXd::Zero(4, 5).template cast<var>();
-  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> c =
-    Eigen::MatrixXd::Zero(5, 6).template cast<var>();
-  std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> va = { a, b, c };
-  for(size_t i = 0; i < va.size(); ++i)
-    for(size_t j = 0; j < va[i].size(); ++j)
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> a
+      = Eigen::MatrixXd::Zero(3, 4).template cast<var>();
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> b
+      = Eigen::MatrixXd::Zero(4, 5).template cast<var>();
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> c
+      = Eigen::MatrixXd::Zero(5, 6).template cast<var>();
+  std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> va
+      = {a, b, c};
+  for (size_t i = 0; i < va.size(); ++i)
+    for (size_t j = 0; j < va[i].size(); ++j)
       va[i](j).vi_->adj_ = i + 1.0;
 
   stan::math::zero_adjoints(va);
-  for(size_t i = 0; i < va.size(); ++i)
-    for(size_t j = 0; j < va[i].size(); ++j)
+  for (size_t i = 0; i < va.size(); ++i)
+    for (size_t j = 0; j < va[i].size(); ++j)
       EXPECT_FLOAT_EQ(va[i](j).vi_->adj_, 0.0);
 
   stan::math::recover_memory();
@@ -209,14 +209,14 @@ TEST(AgradRev, zero_multi) {
   var c(5.0);
   c.vi_->adj_ = 2.0;
   std::vector<var> d(5, 1.0);
-  for(size_t i = 0; i < d.size(); ++i)
+  for (size_t i = 0; i < d.size(); ++i)
     d[i].vi_->adj_ = i + 1.0;
   std::vector<int> e(5, 1);
   std::vector<double> f(5, 1.0);
 
   stan::math::zero_adjoints(a, b, c, d, e, f);
   EXPECT_FLOAT_EQ(c.vi_->adj_, 0.0);
-  for(size_t i = 0; i < d.size(); ++i)
+  for (size_t i = 0; i < d.size(); ++i)
     EXPECT_FLOAT_EQ(d[i].vi_->adj_, 0.0);
 
   stan::math::recover_memory();

From 64805e3668fec81cad4f4df157d4fc33ae1385c6 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Fri, 3 Jul 2020 16:04:37 -0400
Subject: [PATCH 156/189] Added tests for old ode interface adapter code
 (design-docs #19)

---
 ..._ode_std_vector_interface_adapter_test.cpp |  24 ++++
 ..._ode_std_vector_interface_adapter_test.cpp | 111 ++++++++++++++++++
 2 files changed, 135 insertions(+)
 create mode 100644 test/unit/math/prim/functor/integrate_ode_std_vector_interface_adapter_test.cpp
 create mode 100644 test/unit/math/rev/functor/integrate_ode_std_vector_interface_adapter_test.cpp

diff --git a/test/unit/math/prim/functor/integrate_ode_std_vector_interface_adapter_test.cpp b/test/unit/math/prim/functor/integrate_ode_std_vector_interface_adapter_test.cpp
new file mode 100644
index 00000000000..daa627d0434
--- /dev/null
+++ b/test/unit/math/prim/functor/integrate_ode_std_vector_interface_adapter_test.cpp
@@ -0,0 +1,24 @@
+#include <stan/math/prim.hpp>
+#include <test/unit/util.hpp>
+#include <gtest/gtest.h>
+#include <test/unit/math/prim/functor/harmonic_oscillator.hpp>
+#include <vector>
+
+TEST(StanMath, check_values) {
+  harm_osc_ode_data_fun harm_osc;
+  stan::math::internal::integrate_ode_std_vector_interface_adapter<harm_osc_ode_data_fun>
+    harm_osc_adapted(harm_osc);
+
+  std::vector<double> theta = { 0.15 };
+  std::vector<double> y = { 1.0, 0.5 };
+
+  std::vector<double> x(3, 1);
+  std::vector<int> x_int(2, 0);
+
+  double t = 1.0;
+
+  Eigen::VectorXd out1 = stan::math::to_vector(harm_osc(t, y, nullptr, theta, x, x_int));
+  Eigen::VectorXd out2 = harm_osc_adapted(t, stan::math::to_vector(y), nullptr, theta, x, x_int);
+
+  EXPECT_MATRIX_FLOAT_EQ(out1, out2);
+}
diff --git a/test/unit/math/rev/functor/integrate_ode_std_vector_interface_adapter_test.cpp b/test/unit/math/rev/functor/integrate_ode_std_vector_interface_adapter_test.cpp
new file mode 100644
index 00000000000..51ac72e4f25
--- /dev/null
+++ b/test/unit/math/rev/functor/integrate_ode_std_vector_interface_adapter_test.cpp
@@ -0,0 +1,111 @@
+#include <stan/math/rev.hpp>
+#include <test/unit/util.hpp>
+#include <gtest/gtest.h>
+#include <test/unit/math/prim/functor/harmonic_oscillator.hpp>
+#include <vector>
+
+TEST(StanMathRev, vd) {
+  using stan::math::var;
+  harm_osc_ode_data_fun harm_osc;
+  stan::math::internal::integrate_ode_std_vector_interface_adapter<harm_osc_ode_data_fun>
+    harm_osc_adapted(harm_osc);
+
+  std::vector<var> theta = { 0.15 };
+  std::vector<double> y = { 1.0, 0.5 };
+
+  std::vector<double> x(3, 1);
+  std::vector<int> x_int(2, 0);
+
+  double t = 1.0;
+
+  Eigen::Matrix<var, Eigen::Dynamic, 1> out1 = stan::math::to_vector(harm_osc(t, y, nullptr, theta, x, x_int));
+  Eigen::Matrix<var, Eigen::Dynamic, 1> out2 = harm_osc_adapted(t, stan::math::to_vector(y), nullptr, theta, x, x_int);
+
+  stan::math::sum(out1).grad();
+  Eigen::VectorXd adjs1(theta.size());
+  for(size_t i = 0; i < theta.size(); ++i)
+    adjs1(i) = theta[i].adj();
+
+  stan::math::set_zero_all_adjoints();
+
+  stan::math::sum(out2).grad();
+  Eigen::VectorXd adjs2(theta.size());
+  for(size_t i = 0; i < theta.size(); ++i)
+    adjs2(i) = theta[i].adj();
+
+  EXPECT_MATRIX_FLOAT_EQ(out1.val(), out2.val());
+  EXPECT_MATRIX_FLOAT_EQ(adjs1, adjs2);
+}
+
+TEST(StanMathRev, dv) {
+  using stan::math::var;
+  harm_osc_ode_data_fun harm_osc;
+  stan::math::internal::integrate_ode_std_vector_interface_adapter<harm_osc_ode_data_fun>
+    harm_osc_adapted(harm_osc);
+
+  std::vector<double> theta = { 0.15 };
+  std::vector<var> y = { 1.0, 0.5 };
+
+  std::vector<double> x(3, 1);
+  std::vector<int> x_int(2, 0);
+
+  double t = 1.0;
+
+  Eigen::Matrix<var, Eigen::Dynamic, 1> out1 = stan::math::to_vector(harm_osc(t, y, nullptr, theta, x, x_int));
+  Eigen::Matrix<var, Eigen::Dynamic, 1> out2 = harm_osc_adapted(t, stan::math::to_vector(y), nullptr, theta, x, x_int);
+
+  stan::math::sum(out1).grad();
+  Eigen::VectorXd adjs1(y.size());
+  for(size_t i = 0; i < y.size(); ++i)
+    adjs1(i) = y[i].adj();
+
+  stan::math::set_zero_all_adjoints();
+
+  stan::math::sum(out2).grad();
+  Eigen::VectorXd adjs2(y.size());
+  for(size_t i = 0; i < y.size(); ++i)
+    adjs2(i) = y[i].adj();
+
+  EXPECT_MATRIX_FLOAT_EQ(out1.val(), out2.val());
+  EXPECT_MATRIX_FLOAT_EQ(adjs1, adjs2);
+}
+
+TEST(StanMathRev, vv) {
+  using stan::math::var;
+  harm_osc_ode_data_fun harm_osc;
+  stan::math::internal::integrate_ode_std_vector_interface_adapter<harm_osc_ode_data_fun>
+    harm_osc_adapted(harm_osc);
+
+  std::vector<var> theta = { 0.15 };
+  std::vector<var> y = { 1.0, 0.5 };
+
+  std::vector<double> x(3, 1);
+  std::vector<int> x_int(2, 0);
+
+  double t = 1.0;
+
+  Eigen::Matrix<var, Eigen::Dynamic, 1> out1 = stan::math::to_vector(harm_osc(t, y, nullptr, theta, x, x_int));
+  Eigen::Matrix<var, Eigen::Dynamic, 1> out2 = harm_osc_adapted(t, stan::math::to_vector(y), nullptr, theta, x, x_int);
+
+  stan::math::sum(out1).grad();
+  Eigen::VectorXd adjs_theta_1(theta.size());
+  for(size_t i = 0; i < theta.size(); ++i)
+    adjs_theta_1(i) = theta[i].adj();
+  Eigen::VectorXd adjs_y_1(y.size());
+  for(size_t i = 0; i < y.size(); ++i)
+    adjs_y_1(i) = y[i].adj();
+
+  stan::math::set_zero_all_adjoints();
+
+  stan::math::sum(out2).grad();
+  Eigen::VectorXd adjs_theta_2(theta.size());
+  for(size_t i = 0; i < theta.size(); ++i)
+    adjs_theta_2(i) = theta[i].adj();
+  Eigen::VectorXd adjs_y_2(y.size());
+  for(size_t i = 0; i < y.size(); ++i)
+    adjs_y_2(i) = y[i].adj();
+  
+  EXPECT_MATRIX_FLOAT_EQ(out1.val(), out2.val());
+  EXPECT_MATRIX_FLOAT_EQ(adjs_theta_1, adjs_theta_2);
+  EXPECT_MATRIX_FLOAT_EQ(adjs_y_1, adjs_y_2);
+}

From 393b2c98b035d67abe8db8b37f6b6a0e570a85c8 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 3 Jul 2020 16:05:59 -0400
Subject: [PATCH 157/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 ..._ode_std_vector_interface_adapter_test.cpp | 15 +++--
 ..._ode_std_vector_interface_adapter_test.cpp | 63 +++++++++++--------
 2 files changed, 45 insertions(+), 33 deletions(-)

diff --git a/test/unit/math/prim/functor/integrate_ode_std_vector_interface_adapter_test.cpp b/test/unit/math/prim/functor/integrate_ode_std_vector_interface_adapter_test.cpp
index daa627d0434..02d21a8cb0c 100644
--- a/test/unit/math/prim/functor/integrate_ode_std_vector_interface_adapter_test.cpp
+++ b/test/unit/math/prim/functor/integrate_ode_std_vector_interface_adapter_test.cpp
@@ -6,19 +6,22 @@
 
 TEST(StanMath, check_values) {
   harm_osc_ode_data_fun harm_osc;
-  stan::math::internal::integrate_ode_std_vector_interface_adapter<harm_osc_ode_data_fun>
-    harm_osc_adapted(harm_osc);
+  stan::math::internal::integrate_ode_std_vector_interface_adapter<
+      harm_osc_ode_data_fun>
+      harm_osc_adapted(harm_osc);
 
-  std::vector<double> theta = { 0.15 };
-  std::vector<double> y = { 1.0, 0.5 };
+  std::vector<double> theta = {0.15};
+  std::vector<double> y = {1.0, 0.5};
 
   std::vector<double> x(3, 1);
   std::vector<int> x_int(2, 0);
 
   double t = 1.0;
 
-  Eigen::VectorXd out1 = stan::math::to_vector(harm_osc(t, y, nullptr, theta, x, x_int));
-  Eigen::VectorXd out2 = harm_osc_adapted(t, stan::math::to_vector(y), nullptr, theta, x, x_int);
+  Eigen::VectorXd out1
+      = stan::math::to_vector(harm_osc(t, y, nullptr, theta, x, x_int));
+  Eigen::VectorXd out2
+      = harm_osc_adapted(t, stan::math::to_vector(y), nullptr, theta, x, x_int);
 
   EXPECT_MATRIX_FLOAT_EQ(out1, out2);
 }
diff --git a/test/unit/math/rev/functor/integrate_ode_std_vector_interface_adapter_test.cpp b/test/unit/math/rev/functor/integrate_ode_std_vector_interface_adapter_test.cpp
index 51ac72e4f25..5eb1fc098ea 100644
--- a/test/unit/math/rev/functor/integrate_ode_std_vector_interface_adapter_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_std_vector_interface_adapter_test.cpp
@@ -7,30 +7,33 @@
 TEST(StanMathRev, vd) {
   using stan::math::var;
   harm_osc_ode_data_fun harm_osc;
-  stan::math::internal::integrate_ode_std_vector_interface_adapter<harm_osc_ode_data_fun>
-    harm_osc_adapted(harm_osc);
+  stan::math::internal::integrate_ode_std_vector_interface_adapter<
+      harm_osc_ode_data_fun>
+      harm_osc_adapted(harm_osc);
 
-  std::vector<var> theta = { 0.15 };
-  std::vector<double> y = { 1.0, 0.5 };
+  std::vector<var> theta = {0.15};
+  std::vector<double> y = {1.0, 0.5};
 
   std::vector<double> x(3, 1);
   std::vector<int> x_int(2, 0);
 
   double t = 1.0;
 
-  Eigen::Matrix<var, Eigen::Dynamic, 1> out1 = stan::math::to_vector(harm_osc(t, y, nullptr, theta, x, x_int));
-  Eigen::Matrix<var, Eigen::Dynamic, 1> out2 = harm_osc_adapted(t, stan::math::to_vector(y), nullptr, theta, x, x_int);
+  Eigen::Matrix<var, Eigen::Dynamic, 1> out1
+      = stan::math::to_vector(harm_osc(t, y, nullptr, theta, x, x_int));
+  Eigen::Matrix<var, Eigen::Dynamic, 1> out2
+      = harm_osc_adapted(t, stan::math::to_vector(y), nullptr, theta, x, x_int);
 
   stan::math::sum(out1).grad();
   Eigen::VectorXd adjs1(theta.size());
-  for(size_t i = 0; i < theta.size(); ++i)
+  for (size_t i = 0; i < theta.size(); ++i)
     adjs1(i) = theta[i].adj();
 
   stan::math::set_zero_all_adjoints();
 
   stan::math::sum(out2).grad();
   Eigen::VectorXd adjs2(theta.size());
-  for(size_t i = 0; i < theta.size(); ++i)
+  for (size_t i = 0; i < theta.size(); ++i)
     adjs2(i) = theta[i].adj();
 
   EXPECT_MATRIX_FLOAT_EQ(out1.val(), out2.val());
@@ -40,30 +43,33 @@ TEST(StanMathRev, vd) {
 TEST(StanMathRev, dv) {
   using stan::math::var;
   harm_osc_ode_data_fun harm_osc;
-  stan::math::internal::integrate_ode_std_vector_interface_adapter<harm_osc_ode_data_fun>
-    harm_osc_adapted(harm_osc);
+  stan::math::internal::integrate_ode_std_vector_interface_adapter<
+      harm_osc_ode_data_fun>
+      harm_osc_adapted(harm_osc);
 
-  std::vector<double> theta = { 0.15 };
-  std::vector<var> y = { 1.0, 0.5 };
+  std::vector<double> theta = {0.15};
+  std::vector<var> y = {1.0, 0.5};
 
   std::vector<double> x(3, 1);
   std::vector<int> x_int(2, 0);
 
   double t = 1.0;
 
-  Eigen::Matrix<var, Eigen::Dynamic, 1> out1 = stan::math::to_vector(harm_osc(t, y, nullptr, theta, x, x_int));
-  Eigen::Matrix<var, Eigen::Dynamic, 1> out2 = harm_osc_adapted(t, stan::math::to_vector(y), nullptr, theta, x, x_int);
+  Eigen::Matrix<var, Eigen::Dynamic, 1> out1
+      = stan::math::to_vector(harm_osc(t, y, nullptr, theta, x, x_int));
+  Eigen::Matrix<var, Eigen::Dynamic, 1> out2
+      = harm_osc_adapted(t, stan::math::to_vector(y), nullptr, theta, x, x_int);
 
   stan::math::sum(out1).grad();
   Eigen::VectorXd adjs1(y.size());
-  for(size_t i = 0; i < y.size(); ++i)
+  for (size_t i = 0; i < y.size(); ++i)
     adjs1(i) = y[i].adj();
 
   stan::math::set_zero_all_adjoints();
 
   stan::math::sum(out2).grad();
   Eigen::VectorXd adjs2(y.size());
-  for(size_t i = 0; i < y.size(); ++i)
+  for (size_t i = 0; i < y.size(); ++i)
     adjs2(i) = y[i].adj();
 
   EXPECT_MATRIX_FLOAT_EQ(out1.val(), out2.val());
@@ -73,38 +79,41 @@ TEST(StanMathRev, dv) {
 TEST(StanMathRev, vv) {
   using stan::math::var;
   harm_osc_ode_data_fun harm_osc;
-  stan::math::internal::integrate_ode_std_vector_interface_adapter<harm_osc_ode_data_fun>
-    harm_osc_adapted(harm_osc);
+  stan::math::internal::integrate_ode_std_vector_interface_adapter<
+      harm_osc_ode_data_fun>
+      harm_osc_adapted(harm_osc);
 
-  std::vector<var> theta = { 0.15 };
-  std::vector<var> y = { 1.0, 0.5 };
+  std::vector<var> theta = {0.15};
+  std::vector<var> y = {1.0, 0.5};
 
   std::vector<double> x(3, 1);
   std::vector<int> x_int(2, 0);
 
   double t = 1.0;
 
-  Eigen::Matrix<var, Eigen::Dynamic, 1> out1 = stan::math::to_vector(harm_osc(t, y, nullptr, theta, x, x_int));
-  Eigen::Matrix<var, Eigen::Dynamic, 1> out2 = harm_osc_adapted(t, stan::math::to_vector(y), nullptr, theta, x, x_int);
+  Eigen::Matrix<var, Eigen::Dynamic, 1> out1
+      = stan::math::to_vector(harm_osc(t, y, nullptr, theta, x, x_int));
+  Eigen::Matrix<var, Eigen::Dynamic, 1> out2
+      = harm_osc_adapted(t, stan::math::to_vector(y), nullptr, theta, x, x_int);
 
   stan::math::sum(out1).grad();
   Eigen::VectorXd adjs_theta_1(theta.size());
-  for(size_t i = 0; i < theta.size(); ++i)
+  for (size_t i = 0; i < theta.size(); ++i)
     adjs_theta_1(i) = theta[i].adj();
   Eigen::VectorXd adjs_y_1(y.size());
-  for(size_t i = 0; i < y.size(); ++i)
+  for (size_t i = 0; i < y.size(); ++i)
     adjs_y_1(i) = y[i].adj();
 
   stan::math::set_zero_all_adjoints();
 
   stan::math::sum(out2).grad();
   Eigen::VectorXd adjs_theta_2(theta.size());
-  for(size_t i = 0; i < theta.size(); ++i)
+  for (size_t i = 0; i < theta.size(); ++i)
     adjs_theta_2(i) = theta[i].adj();
   Eigen::VectorXd adjs_y_2(y.size());
-  for(size_t i = 0; i < y.size(); ++i)
+  for (size_t i = 0; i < y.size(); ++i)
     adjs_y_2(i) = y[i].adj();
-  
+
   EXPECT_MATRIX_FLOAT_EQ(out1.val(), out2.val());
   EXPECT_MATRIX_FLOAT_EQ(adjs_theta_1, adjs_theta_2);
   EXPECT_MATRIX_FLOAT_EQ(adjs_y_1, adjs_y_2);

From 66bf060a0ccf38b218bb33aabc507e7c0dc37fc8 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Sat, 4 Jul 2020 14:07:27 -0400
Subject: [PATCH 158/189] Clean up doxygen and test names (design-doc #19)

---
 stan/math/prim/functor/ode_rk45.hpp         | 1 +
 stan/math/rev/functor/cvodes_integrator.hpp | 1 +
 stan/math/rev/functor/ode_adams.hpp         | 1 +
 stan/math/rev/functor/ode_bdf.hpp           | 1 +
 test/unit/math/rev/fun/value_of_test.cpp    | 2 +-
 5 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index f1400aa3302..ae0c9aa0095 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -37,6 +37,7 @@ namespace math {
  * @tparam T_ts Type of output times
  * @tparam T_Args Types of pass-through parameters
  *
+ * @param function_name Calling function name (for printing debugging messages)
  * @param f Right hand side of the ODE
  * @param y0_arg Initial state
  * @param t0 Initial time
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 3b6a68bdf92..bedefe608d0 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -160,6 +160,7 @@ class cvodes_integrator {
   /**
    * Construct cvodes_integrator object
    *
+   * @param function_name Calling function name (for printing debugging messages)
    * @param f Right hand side of the ODE
    * @param y0 Initial state
    * @param t0 Initial time
diff --git a/stan/math/rev/functor/ode_adams.hpp b/stan/math/rev/functor/ode_adams.hpp
index 7fc7194a5b1..109e7588f1e 100644
--- a/stan/math/rev/functor/ode_adams.hpp
+++ b/stan/math/rev/functor/ode_adams.hpp
@@ -29,6 +29,7 @@ namespace math {
  * @tparam T_ts Type of output times
  * @tparam T_Args Types of pass-through parameters
  *
+ * @param function_name Calling function name (for printing debugging messages)
  * @param f Right hand side of the ODE
  * @param y0 Initial state
  * @param t0 Initial time
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 95de692719c..769149710d1 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -29,6 +29,7 @@ namespace math {
  * @tparam T_ts Type of output times
  * @tparam T_Args Types of pass-through parameters
  *
+ * @param function_name Calling function name (for printing debugging messages)
  * @param f Right hand side of the ODE
  * @param y0 Initial state
  * @param t0 Initial time
diff --git a/test/unit/math/rev/fun/value_of_test.cpp b/test/unit/math/rev/fun/value_of_test.cpp
index 379a0f41fb3..672c207ad70 100644
--- a/test/unit/math/rev/fun/value_of_test.cpp
+++ b/test/unit/math/rev/fun/value_of_test.cpp
@@ -114,7 +114,7 @@ TEST(AgradMatrix, value_of_vector_of_vectors) {
   }
 }
 
-TEST(MathFunctions, value_of_vector_of_eigen) {
+TEST(AgradMatrix, value_of_vector_of_eigen) {
   using stan::math::var;
   Eigen::Matrix<var, Eigen::Dynamic, 1> a
       = Eigen::VectorXd::Random(5).template cast<var>();

From 2b53b2d9d5007a6f8a05fbb0566d96477db77c89 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Sat, 4 Jul 2020 14:08:44 -0400
Subject: [PATCH 159/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 stan/math/rev/functor/cvodes_integrator.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index bedefe608d0..59a6a4969d1 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -160,7 +160,8 @@ class cvodes_integrator {
   /**
    * Construct cvodes_integrator object
    *
-   * @param function_name Calling function name (for printing debugging messages)
+   * @param function_name Calling function name (for printing debugging
+   * messages)
    * @param f Right hand side of the ODE
    * @param y0 Initial state
    * @param t0 Initial time

From f7452949b292600f3bd82622088c3e8cae5e87f1 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Sat, 4 Jul 2020 14:30:09 -0400
Subject: [PATCH 160/189] Updated headers in zero_adjoints.hpp (design-doc #19)

---
 stan/math/rev/core/zero_adjoints.hpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/stan/math/rev/core/zero_adjoints.hpp b/stan/math/rev/core/zero_adjoints.hpp
index ecbf7389146..4a053378b7e 100644
--- a/stan/math/rev/core/zero_adjoints.hpp
+++ b/stan/math/rev/core/zero_adjoints.hpp
@@ -1,9 +1,8 @@
 #ifndef STAN_MATH_REV_CORE_ZERO_ADJOINTS_HPP
 #define STAN_MATH_REV_CORE_ZERO_ADJOINTS_HPP
 
-#include <stan/math/rev/core/vari.hpp>
-#include <stan/math/rev/core/chainable_alloc.hpp>
-#include <stan/math/rev/core/chainablestack.hpp>
+#include <stan/math/rev/core/var.hpp>
+#include <vector>
 
 namespace stan {
 namespace math {

From 444ae2a4b458e04b7c95ec54c5ddc5ec1d15f6ba Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Sat, 4 Jul 2020 15:03:18 -0400
Subject: [PATCH 161/189] Updated types in coupled_ode_system tests (design-doc
 #19)

---
 .../unit/math/prim/functor/coupled_ode_system_test.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/test/unit/math/prim/functor/coupled_ode_system_test.cpp b/test/unit/math/prim/functor/coupled_ode_system_test.cpp
index cabc8f0e942..679d2b33b7e 100644
--- a/test/unit/math/prim/functor/coupled_ode_system_test.cpp
+++ b/test/unit/math/prim/functor/coupled_ode_system_test.cpp
@@ -32,13 +32,13 @@ TEST_F(StanMathCoupledOdeSystem, initial_state_dd) {
                      std::vector<double>, std::vector<int>>
       coupled_system_dd(base_ode, y0_d, &msgs, theta_d, x, x_int);
 
-  Eigen::VectorXd state = coupled_system_dd.initial_state();
+  std::vector<double> state = coupled_system_dd.initial_state();
   for (int n = 0; n < N; n++)
-    EXPECT_FLOAT_EQ(y0_d(n), state(n))
+    EXPECT_FLOAT_EQ(y0_d(n), state[n])
         << "we don't need derivatives of y0; "
         << "initial state gets the initial values";
   for (size_t n = N; n < state.size(); n++)
-    EXPECT_FLOAT_EQ(0.0, state(n));
+    EXPECT_FLOAT_EQ(0.0, state[n]);
 }
 
 TEST_F(StanMathCoupledOdeSystem, size) {
@@ -73,8 +73,8 @@ TEST_F(StanMathCoupledOdeSystem, recover_exception) {
                      std::vector<double>, std::vector<double>, std::vector<int>>
       coupled_system_dd(throwing_ode, y0_d, &msgs, theta_v, x, x_int);
 
-  Eigen::VectorXd y(3);
-  Eigen::VectorXd dy_dt(3);
+  std::vector<double> y(3);
+  std::vector<double> dy_dt(3);
 
   double t = 10;
 

From b8bc8e45ef714ca75ad9b50c7932ac866465d429 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 6 Jul 2020 10:16:52 -0400
Subject: [PATCH 162/189] Added missing error print (design-doc #19)

---
 stan/math/prim/functor/ode_rk45.hpp           | 21 ++++++++++++-------
 .../integrate_ode_cvodes_grad_rev_test.cpp    |  4 ++--
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index ae0c9aa0095..d53d9e10767 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -66,6 +66,7 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
   using boost::numeric::odeint::max_step_checker;
   using boost::numeric::odeint::runge_kutta_dopri5;
   using boost::numeric::odeint::vector_space_algebra;
+  using boost::numeric::odeint::no_progress_error;
 
   using T_y0_t0 = return_type_t<T_y0, T_t0>;
 
@@ -123,13 +124,19 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
   std::vector<double> initial_coupled_state = coupled_system.initial_state();
 
   const double step_size = 0.1;
-  integrate_times(
-      make_dense_output(absolute_tolerance, relative_tolerance,
-                        runge_kutta_dopri5<std::vector<double>, double,
-                                           std::vector<double>, double>()),
-      std::ref(coupled_system), initial_coupled_state, std::begin(ts_vec),
-      std::end(ts_vec), step_size, filtered_observer,
-      max_step_checker(max_num_steps));
+  try {
+    integrate_times(
+		    make_dense_output(absolute_tolerance, relative_tolerance,
+				      runge_kutta_dopri5<std::vector<double>, double,
+				      std::vector<double>, double>()),
+		    std::ref(coupled_system), initial_coupled_state, std::begin(ts_vec),
+		    std::end(ts_vec), step_size, filtered_observer,
+		    max_step_checker(max_num_steps));
+  } catch (const no_progress_error& e) {
+    throw_domain_error("integrate_ode_rk45", "", ts_vec[time_index + 1],
+                       "Failed to integrate to next output time (",
+                       ") in less than max_num_steps steps");
+  }
 
   return y;
 }
diff --git a/test/unit/math/rev/functor/integrate_ode_cvodes_grad_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_cvodes_grad_rev_test.cpp
index 1c055015098..4d635ff90d2 100644
--- a/test/unit/math/rev/functor/integrate_ode_cvodes_grad_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_cvodes_grad_rev_test.cpp
@@ -38,10 +38,10 @@ class sho_functor {
   inline std::vector<stan::return_type_t<T1, T2>> operator()(
       const T0& t_in,                 // time
       const std::vector<T1>& y_in,    // state
+      std::ostream* msgs,             // error stream
       const std::vector<T2>& theta,   // parameters
       const std::vector<double>& x,   // double data
-      const std::vector<int>& x_int,  // integer data
-      std::ostream* msgs) const {
+      const std::vector<int>& x_int) const {  // integer data
     if (y_in.size() != 2)
       throw std::domain_error("Functor called with inconsistent state");
 

From 56196a3185d7cfbf6e85fed6a0ef54b7cba5cacf Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 6 Jul 2020 14:18:28 +0000
Subject: [PATCH 163/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

---
 stan/math/prim/functor/ode_rk45.hpp                | 14 +++++++-------
 .../functor/integrate_ode_cvodes_grad_rev_test.cpp | 10 +++++-----
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index d53d9e10767..ffcfb9f3bb8 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -64,9 +64,9 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
   using boost::numeric::odeint::integrate_times;
   using boost::numeric::odeint::make_dense_output;
   using boost::numeric::odeint::max_step_checker;
+  using boost::numeric::odeint::no_progress_error;
   using boost::numeric::odeint::runge_kutta_dopri5;
   using boost::numeric::odeint::vector_space_algebra;
-  using boost::numeric::odeint::no_progress_error;
 
   using T_y0_t0 = return_type_t<T_y0, T_t0>;
 
@@ -126,12 +126,12 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
   const double step_size = 0.1;
   try {
     integrate_times(
-		    make_dense_output(absolute_tolerance, relative_tolerance,
-				      runge_kutta_dopri5<std::vector<double>, double,
-				      std::vector<double>, double>()),
-		    std::ref(coupled_system), initial_coupled_state, std::begin(ts_vec),
-		    std::end(ts_vec), step_size, filtered_observer,
-		    max_step_checker(max_num_steps));
+        make_dense_output(absolute_tolerance, relative_tolerance,
+                          runge_kutta_dopri5<std::vector<double>, double,
+                                             std::vector<double>, double>()),
+        std::ref(coupled_system), initial_coupled_state, std::begin(ts_vec),
+        std::end(ts_vec), step_size, filtered_observer,
+        max_step_checker(max_num_steps));
   } catch (const no_progress_error& e) {
     throw_domain_error("integrate_ode_rk45", "", ts_vec[time_index + 1],
                        "Failed to integrate to next output time (",
diff --git a/test/unit/math/rev/functor/integrate_ode_cvodes_grad_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_cvodes_grad_rev_test.cpp
index 4d635ff90d2..c94a6503082 100644
--- a/test/unit/math/rev/functor/integrate_ode_cvodes_grad_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_cvodes_grad_rev_test.cpp
@@ -36,11 +36,11 @@ class sho_functor {
  public:
   template <typename T0, typename T1, typename T2>
   inline std::vector<stan::return_type_t<T1, T2>> operator()(
-      const T0& t_in,                 // time
-      const std::vector<T1>& y_in,    // state
-      std::ostream* msgs,             // error stream
-      const std::vector<T2>& theta,   // parameters
-      const std::vector<double>& x,   // double data
+      const T0& t_in,                         // time
+      const std::vector<T1>& y_in,            // state
+      std::ostream* msgs,                     // error stream
+      const std::vector<T2>& theta,           // parameters
+      const std::vector<double>& x,           // double data
       const std::vector<int>& x_int) const {  // integer data
     if (y_in.size() != 2)
       throw std::domain_error("Functor called with inconsistent state");

From 15eb4ec0dd451e91636c99b6ffc3af68f938909c Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 6 Jul 2020 10:51:04 -0400
Subject: [PATCH 164/189] Fixed check_finite to work with expressions
 (design-doc #19)

---
 stan/math/prim/err/check_finite.hpp           | 8 +++-----
 test/unit/math/prim/err/check_finite_test.cpp | 3 +++
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/stan/math/prim/err/check_finite.hpp b/stan/math/prim/err/check_finite.hpp
index 8bb7a68bb86..ad53468112c 100644
--- a/stan/math/prim/err/check_finite.hpp
+++ b/stan/math/prim/err/check_finite.hpp
@@ -80,18 +80,16 @@ inline void check_finite(const char* function, const char* name,
 /**
  * Return <code>true</code> is the specified matrix is finite.
  *
- * @tparam T_y type of elements in the matrix
- * @tparam R number of rows, can be Eigen::Dynamic
- * @tparam C number of columns, can be Eigen::Dynamic
+ * @tparam Derived Eigen derived type
  *
  * @param function name of function (for error messages)
  * @param name variable name (for error messages)
  * @param y matrix to test
  * @return <code>true</code> if the matrix is finite
  **/
-template <typename T_y, int R, int C>
+template <typename Derived>
 inline void check_finite(const char* function, const char* name,
-                         const Eigen::Matrix<T_y, R, C>& y) {
+                         const Eigen::MatrixBase<Derived>& y) {
   if (!value_of(y).allFinite()) {
     for (int n = 0; n < y.size(); ++n) {
       if (!std::isfinite(value_of_rec(y(n)))) {
diff --git a/test/unit/math/prim/err/check_finite_test.cpp b/test/unit/math/prim/err/check_finite_test.cpp
index 38ef339881a..3744716d317 100644
--- a/test/unit/math/prim/err/check_finite_test.cpp
+++ b/test/unit/math/prim/err/check_finite_test.cpp
@@ -49,6 +49,9 @@ TEST(ErrorHandlingMat, CheckFinite_Matrix) {
   ASSERT_NO_THROW(check_finite(function, "x", x))
       << "check_finite should be true with finite x";
 
+  ASSERT_NO_THROW(check_finite(function, "x", x.transpose()))
+      << "check_finite should be true with finite x";
+
   x.resize(3);
   x << -1, 0, std::numeric_limits<double>::infinity();
   EXPECT_THROW(check_finite(function, "x", x), std::domain_error)

From 5773195b6e88f8d51ffc4898f2fcab79dff3e7ba Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 6 Jul 2020 12:14:10 -0400
Subject: [PATCH 165/189] Updated check_finite to work with eigen arrays
 (design-doc #19)

---
 stan/math/prim/err/check_finite.hpp           | 4 ++--
 stan/math/prim/fun/value_of.hpp               | 2 +-
 test/unit/math/prim/err/check_finite_test.cpp | 3 +++
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/stan/math/prim/err/check_finite.hpp b/stan/math/prim/err/check_finite.hpp
index ad53468112c..2e92cd2ca80 100644
--- a/stan/math/prim/err/check_finite.hpp
+++ b/stan/math/prim/err/check_finite.hpp
@@ -87,9 +87,9 @@ inline void check_finite(const char* function, const char* name,
  * @param y matrix to test
  * @return <code>true</code> if the matrix is finite
  **/
-template <typename Derived>
+template <typename EigMat, require_eigen_t<EigMat>* = nullptr>
 inline void check_finite(const char* function, const char* name,
-                         const Eigen::MatrixBase<Derived>& y) {
+                         const EigMat& y) {
   if (!value_of(y).allFinite()) {
     for (int n = 0; n < y.size(); ++n) {
       if (!std::isfinite(value_of_rec(y(n)))) {
diff --git a/stan/math/prim/fun/value_of.hpp b/stan/math/prim/fun/value_of.hpp
index 7cf488bf7bb..1cfc9aeac39 100644
--- a/stan/math/prim/fun/value_of.hpp
+++ b/stan/math/prim/fun/value_of.hpp
@@ -19,7 +19,7 @@ namespace math {
  **/
 template <typename T, require_st_arithmetic<T>* = nullptr>
 inline decltype(auto) value_of(T&& x) {
-  return std::forward<decltype(x)>(x);
+  return std::forward<T>(x);
 }
 
 /**
diff --git a/test/unit/math/prim/err/check_finite_test.cpp b/test/unit/math/prim/err/check_finite_test.cpp
index 3744716d317..e72a9727eb0 100644
--- a/test/unit/math/prim/err/check_finite_test.cpp
+++ b/test/unit/math/prim/err/check_finite_test.cpp
@@ -49,6 +49,9 @@ TEST(ErrorHandlingMat, CheckFinite_Matrix) {
   ASSERT_NO_THROW(check_finite(function, "x", x))
       << "check_finite should be true with finite x";
 
+  ASSERT_NO_THROW(check_finite(function, "x", x.array()))
+      << "check_finite should be true with finite x";
+
   ASSERT_NO_THROW(check_finite(function, "x", x.transpose()))
       << "check_finite should be true with finite x";
 

From 6d365cefbcec56c6c70633c0b2f04ee179bdda22 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 6 Jul 2020 13:58:51 -0400
Subject: [PATCH 166/189] Cleanup responding to review comments (design-doc
 #19)

---
 stan/math/prim/functor/coupled_ode_system.hpp |  4 +--
 stan/math/prim/functor/integrate_ode_rk45.hpp |  3 +-
 stan/math/prim/functor/ode_rk45.hpp           | 29 ++++++++-----------
 stan/math/rev/core/zero_adjoints.hpp          | 12 +++++---
 stan/math/rev/functor/coupled_ode_system.hpp  |  4 +--
 stan/math/rev/functor/ode_adams.hpp           | 22 +++++++-------
 stan/math/rev/functor/ode_bdf.hpp             | 22 +++++++-------
 7 files changed, 48 insertions(+), 48 deletions(-)

diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
index acf4f2e05de..f9a98a9d4da 100644
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -11,11 +11,11 @@
 namespace stan {
 namespace math {
 
-template <bool Enable, typename F, typename T_y0, typename... Args>
+template <bool ArithmeticArguments, typename F, typename T_y0, typename... Args>
 struct coupled_ode_system_impl;
 
 /**
- * The <code>coupled_ode_system_impl</code> for arithmetic types reduces to
+ * The <code>coupled_ode_system_impl</code> for arithmetic arguments reduces to
  * the regular ode system (there are no sensitivities)
  *
  * @tparam F base ode system functor. Must provide
diff --git a/stan/math/prim/functor/integrate_ode_rk45.hpp b/stan/math/prim/functor/integrate_ode_rk45.hpp
index 214441edd55..f676051e448 100644
--- a/stan/math/prim/functor/integrate_ode_rk45.hpp
+++ b/stan/math/prim/functor/integrate_ode_rk45.hpp
@@ -30,8 +30,9 @@ integrate_ode_rk45(const F& f, const std::vector<T_y0>& y0, const T_t0& t0,
 
   std::vector<std::vector<return_type_t<T_y0, T_param, T_t0, T_ts>>>
       y_converted;
+  y_converted.reserve(y.size());
   for (size_t i = 0; i < y.size(); ++i)
-    y_converted.push_back(to_array_1d(y[i]));
+    y_converted.emplace_back(to_array_1d(y[i]));
 
   return y_converted;
 }
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index ffcfb9f3bb8..6b58b56a1a7 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -14,9 +14,7 @@ namespace math {
 
 /**
  * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
- * times, { t1, t2, t3, ... } using the non-stiff Runge-Kutta 45 solver in Boost
- * with a relative tolerance of 1e-10, an absolute tolerance of 1e-10, and
- * taking a maximum of 1e8 steps.
+ * times, { t1, t2, t3, ... } using the non-stiff Runge-Kutta 45 solver in Boost.
  *
  * If the system of equations is stiff, <code>ode_bdf</code> will likely be
  * faster.
@@ -27,9 +25,9 @@ namespace math {
  *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
  *     std::ostream* msgs, const T_Args&... args);
  *
- * t is the time, y is the state, msgs is a stream for error messages, and args
- * are optional arguments passed to the ODE solve function (which are passed
- * through to \p f without modification).
+ * t is the time, y is the vector-valued state, msgs is a stream for error
+ * messages, and args are optional arguments passed to the ODE solve function 
+ * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
  * @tparam T_y0 Type of initial condition
@@ -143,9 +141,7 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
 
 /**
  * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
- * times, { t1, t2, t3, ... } using the non-stiff Runge-Kutta 45 solver in Boost
- * with a relative tolerance of 1e-10, an absolute tolerance of 1e-10, and
- * taking a maximum of 1e8 steps.
+ * times, { t1, t2, t3, ... } using the non-stiff Runge-Kutta 45 solver in Boost.
  *
  * If the system of equations is stiff, <code>ode_bdf</code> will likely be
  * faster.
@@ -156,9 +152,9 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
  *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
  *     std::ostream* msgs, const T_Args&... args);
  *
- * t is the time, y is the state, msgs is a stream for error messages, and args
- * are optional arguments passed to the ODE solve function (which are passed
- * through to \p f without modification).
+ * t is the time, y is the vector-valued state, msgs is a stream for error
+ * messages, and args are optional arguments passed to the ODE solve function 
+ * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
  * @tparam T_0 Type of initial time
@@ -195,8 +191,7 @@ ode_rk45_tol(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0_arg,
 /**
  * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
  * times, { t1, t2, t3, ... } using the non-stiff Runge-Kutta 45 solver in Boost
- * with a relative tolerance of 1e-10, an absolute tolerance of 1e-10, and
- * taking a maximum of 1e8 steps.
+ * with defaults for relative_tolerance, absolute_tolerance, and max_num_steps.
  *
  * If the system of equations is stiff, <code>ode_bdf</code> will likely be
  * faster.
@@ -207,9 +202,9 @@ ode_rk45_tol(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0_arg,
  *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
  *     std::ostream* msgs, const T_Args&... args);
  *
- * t is the time, y is the state, msgs is a stream for error messages, and args
- * are optional arguments passed to the ODE solve function (which are passed
- * through to \p f without modification).
+ * t is the time, y is the vector-valued state, msgs is a stream for error
+ * messages, and args are optional arguments passed to the ODE solve function 
+ * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
  * @tparam T_y0 Type of initial time
diff --git a/stan/math/rev/core/zero_adjoints.hpp b/stan/math/rev/core/zero_adjoints.hpp
index 4a053378b7e..3a5ed00673c 100644
--- a/stan/math/rev/core/zero_adjoints.hpp
+++ b/stan/math/rev/core/zero_adjoints.hpp
@@ -9,7 +9,8 @@ namespace math {
 
 inline void zero_adjoints();
 
-template <typename T, typename... Pargs>
+template <typename T, typename... Pargs,
+	  require_st_arithmetic<T>* = nullptr>
 inline void zero_adjoints(T& x, Pargs&... args);
 
 template <typename... Pargs>
@@ -18,7 +19,8 @@ inline void zero_adjoints(var& x, Pargs&... args);
 template <int R, int C, typename... Pargs>
 inline void zero_adjoints(Eigen::Matrix<var, R, C>& x, Pargs&... args);
 
-template <typename T, typename... Pargs>
+template <typename T, typename... Pargs,
+	  require_st_autodiff<T>* = nullptr>
 inline void zero_adjoints(std::vector<T>& x, Pargs&... args);
 
 /**
@@ -36,7 +38,8 @@ inline void zero_adjoints() {}
  * @param x current argument
  * @param args rest of arguments to zero
  */
-template <typename T, typename... Pargs>
+template <typename T, typename... Pargs,
+	  require_st_arithmetic<T>*>
 inline void zero_adjoints(T& x, Pargs&... args) {
   zero_adjoints(args...);
 }
@@ -84,7 +87,8 @@ inline void zero_adjoints(Eigen::Matrix<var, R, C>& x, Pargs&... args) {
  * @param x current argument
  * @param args rest of arguments to zero
  */
-template <typename T, typename... Pargs>
+template <typename T, typename... Pargs,
+	  require_st_autodiff<T>*>
 inline void zero_adjoints(std::vector<T>& x, Pargs&... args) {
   for (size_t i = 0; i < x.size(); ++i)
     zero_adjoints(x[i]);
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index 79cecf6583e..e9c9eb5fefc 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -15,8 +15,8 @@ namespace stan {
 namespace math {
 
 /**
- * The <code>coupled_ode_system_impl</code> template specialization
- * for unknown initial values and unknown parameters.
+ * The <code>coupled_ode_system_impl</code> template specialization when
+ * the state or parameters are autodiff types.
  *
  * <p>This coupled ode system has N + (N +  M) * N states where N is
  * the size of the base ode system and M is the number of parameters.
diff --git a/stan/math/rev/functor/ode_adams.hpp b/stan/math/rev/functor/ode_adams.hpp
index 109e7588f1e..93d1c5f225d 100644
--- a/stan/math/rev/functor/ode_adams.hpp
+++ b/stan/math/rev/functor/ode_adams.hpp
@@ -20,9 +20,9 @@ namespace math {
  *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
  *     std::ostream* msgs, const T_Args&... args);
  *
- * t is the time, y is the state, msgs is a stream for error messages, and args
- * are optional arguments passed to the ODE solve function (which are passed
- * through to \p f without modification).
+ * t is the time, y is the vector-valued state, msgs is a stream for error
+ * messages, and args are optional arguments passed to the ODE solve function 
+ * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
  * @tparam T_0 Type of initial time
@@ -71,9 +71,9 @@ ode_adams_tol_impl(const char* function_name, const F& f,
  *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
  *     std::ostream* msgs, const T_Args&... args);
  *
- * t is the time, y is the state, msgs is a stream for error messages, and args
- * are optional arguments passed to the ODE solve function (which are passed
- * through to \p f without modification).
+ * t is the time, y is the vector-valued state, msgs is a stream for error
+ * messages, and args are optional arguments passed to the ODE solve function 
+ * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
  * @tparam T_0 Type of initial time
@@ -109,8 +109,8 @@ ode_adams_tol(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
 /**
  * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
  * times, { t1, t2, t3, ... } using the non-stiff Adams-Moulton
- * solver in CVODES with a relative tolerance of 1e-10, an absolute
- * tolerance of 1e-10, and taking a maximum of 1e8 steps.
+ * solver in CVODES with defaults for relative_tolerance, absolute_tolerance,
+ * and max_num_steps.
  *
  * \p f must define an operator() with the signature as:
  *   template<typename T_t, typename T_y, typename... T_Args>
@@ -118,9 +118,9 @@ ode_adams_tol(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
  *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
  *     std::ostream* msgs, const T_Args&... args);
  *
- * t is the time, y is the state, msgs is a stream for error messages, and args
- * are optional arguments passed to the ODE solve function (which are passed
- * through to \p f without modification).
+ * t is the time, y is the vector-valued state, msgs is a stream for error
+ * messages, and args are optional arguments passed to the ODE solve function 
+ * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
  * @tparam T_0 Type of initial time
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 769149710d1..3a000048f05 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -20,9 +20,9 @@ namespace math {
  *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
  *     std::ostream* msgs, const T_Args&... args);
  *
- * t is the time, y is the state, msgs is a stream for error messages, and args
- * are optional arguments passed to the ODE solve function (which are passed
- * through to \p f without modification).
+ * t is the time, y is the vector-valued state, msgs is a stream for error
+ * messages, and args are optional arguments passed to the ODE solve function 
+ * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
  * @tparam T_0 Type of initial time
@@ -71,9 +71,9 @@ ode_bdf_tol_impl(const char* function_name, const F& f,
  *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
  *     std::ostream* msgs, const T_Args&... args);
  *
- * t is the time, y is the state, msgs is a stream for error messages, and args
- * are optional arguments passed to the ODE solve function (which are passed
- * through to \p f without modification).
+ * t is the time, y is the vector-valued state, msgs is a stream for error
+ * messages, and args are optional arguments passed to the ODE solve function 
+ * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
  * @tparam T_0 Type of initial time
@@ -109,8 +109,8 @@ ode_bdf_tol(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
 /**
  * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
  * times, { t1, t2, t3, ... } using the stiff backward differentiation formula
- * (BDF) solver in CVODES with a relative tolerance of 1e-10, an absolute
- * tolerance of 1e-10, and taking a maximum of 1e8 steps.
+ * (BDF) solver in CVODES with defaults for relative_tolerance, absolute_tolerance,
+ * and max_num_steps.
  *
  * \p f must define an operator() with the signature as:
  *   template<typename T_t, typename T_y, typename... T_Args>
@@ -118,9 +118,9 @@ ode_bdf_tol(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
  *     operator()(const T_t& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
  *     std::ostream* msgs, const T_Args&... args);
  *
- * t is the time, y is the state, msgs is a stream for error messages, and args
- * are optional arguments passed to the ODE solve function (which are passed
- * through to \p f without modification).
+ * t is the time, y is the vector-valued state, msgs is a stream for error
+ * messages, and args are optional arguments passed to the ODE solve function 
+ * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
  * @tparam T_0 Type of initial time

From 0c183380e96589635bae519a0e1594a3d88283f0 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 6 Jul 2020 18:01:32 +0000
Subject: [PATCH 167/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

---
 stan/math/prim/functor/ode_rk45.hpp  | 12 +++++++-----
 stan/math/rev/core/zero_adjoints.hpp | 12 ++++--------
 stan/math/rev/functor/ode_adams.hpp  |  6 +++---
 stan/math/rev/functor/ode_bdf.hpp    | 10 +++++-----
 4 files changed, 19 insertions(+), 21 deletions(-)

diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index 6b58b56a1a7..f2ffc111def 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -14,7 +14,8 @@ namespace math {
 
 /**
  * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
- * times, { t1, t2, t3, ... } using the non-stiff Runge-Kutta 45 solver in Boost.
+ * times, { t1, t2, t3, ... } using the non-stiff Runge-Kutta 45 solver in
+ * Boost.
  *
  * If the system of equations is stiff, <code>ode_bdf</code> will likely be
  * faster.
@@ -26,7 +27,7 @@ namespace math {
  *     std::ostream* msgs, const T_Args&... args);
  *
  * t is the time, y is the vector-valued state, msgs is a stream for error
- * messages, and args are optional arguments passed to the ODE solve function 
+ * messages, and args are optional arguments passed to the ODE solve function
  * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
@@ -141,7 +142,8 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
 
 /**
  * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
- * times, { t1, t2, t3, ... } using the non-stiff Runge-Kutta 45 solver in Boost.
+ * times, { t1, t2, t3, ... } using the non-stiff Runge-Kutta 45 solver in
+ * Boost.
  *
  * If the system of equations is stiff, <code>ode_bdf</code> will likely be
  * faster.
@@ -153,7 +155,7 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
  *     std::ostream* msgs, const T_Args&... args);
  *
  * t is the time, y is the vector-valued state, msgs is a stream for error
- * messages, and args are optional arguments passed to the ODE solve function 
+ * messages, and args are optional arguments passed to the ODE solve function
  * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
@@ -203,7 +205,7 @@ ode_rk45_tol(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0_arg,
  *     std::ostream* msgs, const T_Args&... args);
  *
  * t is the time, y is the vector-valued state, msgs is a stream for error
- * messages, and args are optional arguments passed to the ODE solve function 
+ * messages, and args are optional arguments passed to the ODE solve function
  * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
diff --git a/stan/math/rev/core/zero_adjoints.hpp b/stan/math/rev/core/zero_adjoints.hpp
index 3a5ed00673c..fdfaa689933 100644
--- a/stan/math/rev/core/zero_adjoints.hpp
+++ b/stan/math/rev/core/zero_adjoints.hpp
@@ -9,8 +9,7 @@ namespace math {
 
 inline void zero_adjoints();
 
-template <typename T, typename... Pargs,
-	  require_st_arithmetic<T>* = nullptr>
+template <typename T, typename... Pargs, require_st_arithmetic<T>* = nullptr>
 inline void zero_adjoints(T& x, Pargs&... args);
 
 template <typename... Pargs>
@@ -19,8 +18,7 @@ inline void zero_adjoints(var& x, Pargs&... args);
 template <int R, int C, typename... Pargs>
 inline void zero_adjoints(Eigen::Matrix<var, R, C>& x, Pargs&... args);
 
-template <typename T, typename... Pargs,
-	  require_st_autodiff<T>* = nullptr>
+template <typename T, typename... Pargs, require_st_autodiff<T>* = nullptr>
 inline void zero_adjoints(std::vector<T>& x, Pargs&... args);
 
 /**
@@ -38,8 +36,7 @@ inline void zero_adjoints() {}
  * @param x current argument
  * @param args rest of arguments to zero
  */
-template <typename T, typename... Pargs,
-	  require_st_arithmetic<T>*>
+template <typename T, typename... Pargs, require_st_arithmetic<T>*>
 inline void zero_adjoints(T& x, Pargs&... args) {
   zero_adjoints(args...);
 }
@@ -87,8 +84,7 @@ inline void zero_adjoints(Eigen::Matrix<var, R, C>& x, Pargs&... args) {
  * @param x current argument
  * @param args rest of arguments to zero
  */
-template <typename T, typename... Pargs,
-	  require_st_autodiff<T>*>
+template <typename T, typename... Pargs, require_st_autodiff<T>*>
 inline void zero_adjoints(std::vector<T>& x, Pargs&... args) {
   for (size_t i = 0; i < x.size(); ++i)
     zero_adjoints(x[i]);
diff --git a/stan/math/rev/functor/ode_adams.hpp b/stan/math/rev/functor/ode_adams.hpp
index 93d1c5f225d..93faef9c959 100644
--- a/stan/math/rev/functor/ode_adams.hpp
+++ b/stan/math/rev/functor/ode_adams.hpp
@@ -21,7 +21,7 @@ namespace math {
  *     std::ostream* msgs, const T_Args&... args);
  *
  * t is the time, y is the vector-valued state, msgs is a stream for error
- * messages, and args are optional arguments passed to the ODE solve function 
+ * messages, and args are optional arguments passed to the ODE solve function
  * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
@@ -72,7 +72,7 @@ ode_adams_tol_impl(const char* function_name, const F& f,
  *     std::ostream* msgs, const T_Args&... args);
  *
  * t is the time, y is the vector-valued state, msgs is a stream for error
- * messages, and args are optional arguments passed to the ODE solve function 
+ * messages, and args are optional arguments passed to the ODE solve function
  * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
@@ -119,7 +119,7 @@ ode_adams_tol(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
  *     std::ostream* msgs, const T_Args&... args);
  *
  * t is the time, y is the vector-valued state, msgs is a stream for error
- * messages, and args are optional arguments passed to the ODE solve function 
+ * messages, and args are optional arguments passed to the ODE solve function
  * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 3a000048f05..0929676c1bd 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -21,7 +21,7 @@ namespace math {
  *     std::ostream* msgs, const T_Args&... args);
  *
  * t is the time, y is the vector-valued state, msgs is a stream for error
- * messages, and args are optional arguments passed to the ODE solve function 
+ * messages, and args are optional arguments passed to the ODE solve function
  * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
@@ -72,7 +72,7 @@ ode_bdf_tol_impl(const char* function_name, const F& f,
  *     std::ostream* msgs, const T_Args&... args);
  *
  * t is the time, y is the vector-valued state, msgs is a stream for error
- * messages, and args are optional arguments passed to the ODE solve function 
+ * messages, and args are optional arguments passed to the ODE solve function
  * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side
@@ -109,8 +109,8 @@ ode_bdf_tol(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
 /**
  * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
  * times, { t1, t2, t3, ... } using the stiff backward differentiation formula
- * (BDF) solver in CVODES with defaults for relative_tolerance, absolute_tolerance,
- * and max_num_steps.
+ * (BDF) solver in CVODES with defaults for relative_tolerance,
+ * absolute_tolerance, and max_num_steps.
  *
  * \p f must define an operator() with the signature as:
  *   template<typename T_t, typename T_y, typename... T_Args>
@@ -119,7 +119,7 @@ ode_bdf_tol(const F& f, const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0,
  *     std::ostream* msgs, const T_Args&... args);
  *
  * t is the time, y is the vector-valued state, msgs is a stream for error
- * messages, and args are optional arguments passed to the ODE solve function 
+ * messages, and args are optional arguments passed to the ODE solve function
  * (which are passed through to \p f without modification).
  *
  * @tparam F Type of ODE right hand side

From 7538e97e8d3cb5f83080089a3c50ad3bfc08073c Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 6 Jul 2020 19:24:09 -0400
Subject: [PATCH 168/189] Updated some includes (design-doc #19)

---
 stan/math/prim/err/check_sorted.hpp                             | 1 -
 stan/math/prim/functor/coupled_ode_system.hpp                   | 2 +-
 stan/math/prim/functor/ode_rk45.hpp                             | 2 +-
 stan/math/prim/functor/ode_store_sensitivities.hpp              | 1 +
 stan/math/rev/core/grad.hpp                                     | 1 -
 stan/math/rev/core/zero_adjoints.hpp                            | 1 +
 stan/math/rev/functor/ode_adams.hpp                             | 1 +
 stan/math/rev/functor/ode_bdf.hpp                               | 1 +
 test/unit/math/prim/err/check_sorted_test.cpp                   | 2 +-
 .../functor/integrate_ode_std_vector_interface_adapter_test.cpp | 2 +-
 10 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/stan/math/prim/err/check_sorted.hpp b/stan/math/prim/err/check_sorted.hpp
index 93a6be2321b..702a4466787 100644
--- a/stan/math/prim/err/check_sorted.hpp
+++ b/stan/math/prim/err/check_sorted.hpp
@@ -1,7 +1,6 @@
 #ifndef STAN_MATH_PRIM_ERR_CHECK_SORTED_HPP
 #define STAN_MATH_PRIM_ERR_CHECK_SORTED_HPP
 
-#include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err/throw_domain_error.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <sstream>
diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
index f9a98a9d4da..007446a7900 100644
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -1,10 +1,10 @@
 #ifndef STAN_MATH_PRIM_FUNCTOR_COUPLED_ODE_SYSTEM_HPP
 #define STAN_MATH_PRIM_FUNCTOR_COUPLED_ODE_SYSTEM_HPP
 
-#include <stan/math/prim/fun/value_of.hpp>
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/err.hpp>
 #include <stan/math/prim/fun/size.hpp>
+#include <stan/math/prim/functor/apply.hpp>
 #include <ostream>
 #include <vector>
 
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index 6b58b56a1a7..46833e63352 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -4,7 +4,7 @@
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/functor/coupled_ode_system.hpp>
 #include <stan/math/prim/functor/ode_store_sensitivities.hpp>
-#include <boost/numeric/odeint/external/eigen/eigen_algebra.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <boost/numeric/odeint.hpp>
 #include <ostream>
 #include <vector>
diff --git a/stan/math/prim/functor/ode_store_sensitivities.hpp b/stan/math/prim/functor/ode_store_sensitivities.hpp
index 82a0969aabb..ec42a5506e4 100644
--- a/stan/math/prim/functor/ode_store_sensitivities.hpp
+++ b/stan/math/prim/functor/ode_store_sensitivities.hpp
@@ -2,6 +2,7 @@
 #define STAN_MATH_PRIM_FUNCTOR_ODE_STORE_SENSITIVITIES_HPP
 
 #include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <ostream>
 #include <vector>
 
diff --git a/stan/math/rev/core/grad.hpp b/stan/math/rev/core/grad.hpp
index 15d4d720bc4..df644615353 100644
--- a/stan/math/rev/core/grad.hpp
+++ b/stan/math/rev/core/grad.hpp
@@ -7,7 +7,6 @@
 #include <stan/math/rev/core/nested_size.hpp>
 #include <stan/math/rev/core/vari.hpp>
 #include <vector>
-#include <iostream>
 
 namespace stan {
 namespace math {
diff --git a/stan/math/rev/core/zero_adjoints.hpp b/stan/math/rev/core/zero_adjoints.hpp
index 3a5ed00673c..07f693468c4 100644
--- a/stan/math/rev/core/zero_adjoints.hpp
+++ b/stan/math/rev/core/zero_adjoints.hpp
@@ -2,6 +2,7 @@
 #define STAN_MATH_REV_CORE_ZERO_ADJOINTS_HPP
 
 #include <stan/math/rev/core/var.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <vector>
 
 namespace stan {
diff --git a/stan/math/rev/functor/ode_adams.hpp b/stan/math/rev/functor/ode_adams.hpp
index 93d1c5f225d..a6566d78835 100644
--- a/stan/math/rev/functor/ode_adams.hpp
+++ b/stan/math/rev/functor/ode_adams.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/functor/cvodes_integrator.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <ostream>
 #include <vector>
 
diff --git a/stan/math/rev/functor/ode_bdf.hpp b/stan/math/rev/functor/ode_bdf.hpp
index 3a000048f05..9a153c5b878 100644
--- a/stan/math/rev/functor/ode_bdf.hpp
+++ b/stan/math/rev/functor/ode_bdf.hpp
@@ -3,6 +3,7 @@
 
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/functor/cvodes_integrator.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <ostream>
 #include <vector>
 
diff --git a/test/unit/math/prim/err/check_sorted_test.cpp b/test/unit/math/prim/err/check_sorted_test.cpp
index 7cdfed74ee4..41d1450fd69 100644
--- a/test/unit/math/prim/err/check_sorted_test.cpp
+++ b/test/unit/math/prim/err/check_sorted_test.cpp
@@ -1,4 +1,4 @@
-#include <stan/math/prim.hpp>
+#include <stan/math/prim/err/check_sorted.hpp>
 #include <gtest/gtest.h>
 #include <limits>
 #include <string>
diff --git a/test/unit/math/prim/functor/integrate_ode_std_vector_interface_adapter_test.cpp b/test/unit/math/prim/functor/integrate_ode_std_vector_interface_adapter_test.cpp
index 02d21a8cb0c..8009cbdbb65 100644
--- a/test/unit/math/prim/functor/integrate_ode_std_vector_interface_adapter_test.cpp
+++ b/test/unit/math/prim/functor/integrate_ode_std_vector_interface_adapter_test.cpp
@@ -1,4 +1,4 @@
-#include <stan/math/prim.hpp>
+#include <stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp>
 #include <test/unit/util.hpp>
 #include <gtest/gtest.h>
 #include <test/unit/math/prim/functor/harmonic_oscillator.hpp>

From c2499bec1483f1db54a95253fa6accd2b5084d03 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Tue, 7 Jul 2020 13:41:31 -0400
Subject: [PATCH 169/189] Responding to comments. Added too much work tests to
 _tol versions of ode functions (design-doc #19)

---
 stan/math/rev/core/accumulate_adjoints.hpp    |  4 +--
 stan/math/rev/core/save_varis.hpp             |  4 +--
 stan/math/rev/functor/coupled_ode_system.hpp  | 28 +++++++++---------
 stan/math/rev/functor/cvodes_integrator.hpp   | 28 +++++++++---------
 stan/math/rev/functor/ode_adams.hpp           |  8 ++---
 .../rev/functor/ode_store_sensitivities.hpp   | 26 ++++++++---------
 .../math/prim/functor/ode_rk45_prim_test.cpp  | 12 +++++---
 .../prim/functor/ode_rk45_tol_prim_test.cpp   | 23 +++++++++++++--
 .../math/rev/functor/ode_adams_prim_test.cpp  | 13 +++++----
 .../math/rev/functor/ode_adams_rev_test.cpp   |  2 ++
 .../rev/functor/ode_adams_tol_prim_test.cpp   | 29 +++++++++++++++----
 .../rev/functor/ode_adams_tol_rev_test.cpp    | 16 ++++++++++
 .../math/rev/functor/ode_bdf_prim_test.cpp    | 12 +++++---
 .../math/rev/functor/ode_bdf_rev_test.cpp     |  2 ++
 .../rev/functor/ode_bdf_tol_prim_test.cpp     | 29 +++++++++++++++----
 .../math/rev/functor/ode_bdf_tol_rev_test.cpp | 16 ++++++++++
 .../math/rev/functor/ode_rk45_rev_test.cpp    |  2 ++
 .../rev/functor/ode_rk45_tol_rev_test.cpp     | 16 ++++++++++
 18 files changed, 192 insertions(+), 78 deletions(-)

diff --git a/stan/math/rev/core/accumulate_adjoints.hpp b/stan/math/rev/core/accumulate_adjoints.hpp
index 98f0899119d..29fd191afff 100644
--- a/stan/math/rev/core/accumulate_adjoints.hpp
+++ b/stan/math/rev/core/accumulate_adjoints.hpp
@@ -29,7 +29,7 @@ template <typename EigT, require_eigen_vt<is_var, EigT>* = nullptr,
           typename... Pargs>
 inline double* accumulate_adjoints(double* dest, EigT&& x, Pargs&&... args);
 
-template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>* = nullptr,
+template <typename Arith, require_st_arithmetic<Arith>* = nullptr,
           typename... Pargs>
 inline double* accumulate_adjoints(double* dest, Arith&& x, Pargs&&... args);
 
@@ -135,7 +135,7 @@ inline double* accumulate_adjoints(double* dest, EigT&& x, Pargs&&... args) {
  * @param args Further args to accumulate over
  * @return Final position of adjoint storage pointer
  */
-template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>*,
+template <typename Arith, require_st_arithmetic<Arith>*,
           typename... Pargs>
 inline double* accumulate_adjoints(double* dest, Arith&& x, Pargs&&... args) {
   return accumulate_adjoints(dest, std::forward<Pargs>(args)...);
diff --git a/stan/math/rev/core/save_varis.hpp b/stan/math/rev/core/save_varis.hpp
index dfeefa71728..a252ce5c07e 100644
--- a/stan/math/rev/core/save_varis.hpp
+++ b/stan/math/rev/core/save_varis.hpp
@@ -29,7 +29,7 @@ template <typename EigT, require_eigen_vt<is_var, EigT>* = nullptr,
           typename... Pargs>
 inline vari** save_varis(vari** dest, EigT&& x, Pargs&&... args);
 
-template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>* = nullptr,
+template <typename Arith, require_st_arithmetic<Arith>* = nullptr,
           typename... Pargs>
 inline vari** save_varis(vari** dest, Arith&& x, Pargs&&... args);
 
@@ -131,7 +131,7 @@ inline vari** save_varis(vari** dest, EigT&& x, Pargs&&... args) {
  * @param[in] args Additional arguments to have their varis saved
  * @return Final position of dest pointer
  */
-template <typename Arith, require_arithmetic_t<scalar_type_t<Arith>>*,
+template <typename Arith, require_st_arithmetic<Arith>*,
           typename... Pargs>
 inline vari** save_varis(vari** dest, Arith&& x, Pargs&&... args) {
   return save_varis(dest, std::forward<Pargs>(args)...);
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index e9c9eb5fefc..6f6a29a55c6 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -69,8 +69,8 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
   const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0_;
   std::tuple<decltype(deep_copy_vars(std::declval<Args>()))...>
       local_args_tuple_;
-  const size_t y0_vars_;
-  const size_t args_vars_;
+  const size_t num_y0_vars_;
+  const size_t num_args_vars;
   const size_t N_;
   Eigen::VectorXd args_adjoints_;
   Eigen::VectorXd y_adjoints_;
@@ -92,10 +92,10 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
       : f_(f),
         y0_(y0),
         local_args_tuple_(deep_copy_vars(args)...),
-        y0_vars_(count_vars(y0_)),
-        args_vars_(count_vars(args...)),
+        num_y0_vars_(count_vars(y0_)),
+        num_args_vars(count_vars(args...)),
         N_(y0.size()),
-        args_adjoints_(args_vars_),
+        args_adjoints_(num_args_vars),
         y_adjoints_(N_),
         msgs_(msgs) {}
 
@@ -103,8 +103,6 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
    * Calculates the right hand side of the coupled ode system (the regular
    * ode system with forward sensitivities).
    *
-   * This method uses nested autodiff and is not thread safe.
-   *
    * @param[in] z state of the coupled ode system; this must be size
    *   <code>size()</code>
    * @param[out] dz_dt a vector of size <code>size()</code> with the
@@ -139,7 +137,7 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
 
       y_adjoints_ = y_vars.adj();
 
-      memset(args_adjoints_.data(), 0, sizeof(double) * args_vars_);
+      memset(args_adjoints_.data(), 0, sizeof(double) * num_args_vars);
       apply(
           [&](auto&&... args) {
             accumulate_adjoints(args_adjoints_.data(), args...);
@@ -149,11 +147,11 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
       apply([&](auto&&... args) { zero_adjoints(args...); }, local_args_tuple_);
 
       // No need to zero adjoints after last sweep
-      if (i < N_) {
+      if (i + 1 < N_) {
         nested.set_zero_all_adjoints();
       }
 
-      for (size_t j = 0; j < y0_vars_; ++j) {
+      for (size_t j = 0; j < num_y0_vars_; ++j) {
         double temp_deriv = 0.0;
         for (size_t k = 0; k < N_; ++k) {
           temp_deriv += z[N_ + N_ * j + k] * y_adjoints_.coeffRef(k);
@@ -162,14 +160,14 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
         dz_dt[N_ + N_ * j + i] = temp_deriv;
       }
 
-      for (size_t j = 0; j < args_vars_; ++j) {
+      for (size_t j = 0; j < num_args_vars; ++j) {
         double temp_deriv = args_adjoints_.coeffRef(j);
         for (size_t k = 0; k < N_; ++k) {
           temp_deriv
-              += z[N_ + N_ * y0_vars_ + N_ * j + k] * y_adjoints_.coeffRef(k);
+              += z[N_ + N_ * num_y0_vars_ + N_ * j + k] * y_adjoints_.coeffRef(k);
         }
 
-        dz_dt[N_ + N_ * y0_vars_ + N_ * j + i] = temp_deriv;
+        dz_dt[N_ + N_ * num_y0_vars_ + N_ * j + i] = temp_deriv;
       }
     }
   }
@@ -179,7 +177,7 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
    *
    * @return size of the coupled system.
    */
-  size_t size() const { return N_ + N_ * y0_vars_ + N_ * args_vars_; }
+  size_t size() const { return N_ + N_ * num_y0_vars_ + N_ * num_args_vars; }
 
   /**
    * Returns the initial state of the coupled system.
@@ -204,7 +202,7 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
     for (size_t i = 0; i < N_; i++) {
       initial[i] = value_of(y0_(i));
     }
-    for (size_t i = 0; i < y0_vars_; i++) {
+    for (size_t i = 0; i < num_y0_vars_; i++) {
       initial[N_ + i * N_ + i] = 1.0;
     }
     return initial;
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 59a6a4969d1..3a1c31dfff2 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -48,8 +48,8 @@ class cvodes_integrator {
   double absolute_tolerance_;
   long int max_num_steps_;  // NOLINT(runtime/int)
 
-  const size_t y0_vars_;
-  const size_t args_vars_;
+  const size_t num_y0_vars_;
+  const size_t num_args_vars_;
 
   coupled_ode_system<F, T_y0_t0, T_Args...> coupled_ode_;
 
@@ -145,12 +145,12 @@ class cvodes_integrator {
     std::vector<double> z(coupled_state_.size());
     std::vector<double> dz_dt;
     std::copy(y, y + N_, z.data());
-    for (std::size_t s = 0; s < y0_vars_ + args_vars_; s++) {
+    for (std::size_t s = 0; s < num_y0_vars_ + num_args_vars_; s++) {
       std::copy(NV_DATA_S(yS[s]), NV_DATA_S(yS[s]) + N_,
                 z.data() + (s + 1) * N_);
     }
     coupled_ode_(z, dz_dt, t);
-    for (std::size_t s = 0; s < y0_vars_ + args_vars_; s++) {
+    for (std::size_t s = 0; s < num_y0_vars_ + num_args_vars_; s++) {
       std::move(dz_dt.data() + (s + 1) * N_, dz_dt.data() + (s + 2) * N_,
                 NV_DATA_S(ySdot[s]));
     }
@@ -201,8 +201,8 @@ class cvodes_integrator {
         relative_tolerance_(relative_tolerance),
         absolute_tolerance_(absolute_tolerance),
         max_num_steps_(max_num_steps),
-        y0_vars_(count_vars(y0_)),
-        args_vars_(count_vars(args...)),
+        num_y0_vars_(count_vars(y0_)),
+        num_args_vars_(count_vars(args...)),
         coupled_ode_(f, y0_, msgs, args...),
         coupled_state_(coupled_ode_.initial_state()) {
     check_finite(function_name, "initial state", y0_);
@@ -234,10 +234,10 @@ class cvodes_integrator {
     A_ = SUNDenseMatrix(N_, N_);
     LS_ = SUNDenseLinearSolver(nv_state_, A_);
 
-    if (y0_vars_ + args_vars_ > 0) {
+    if (num_y0_vars_ + num_args_vars_ > 0) {
       nv_state_sens_
-          = N_VCloneVectorArrayEmpty_Serial(y0_vars_ + args_vars_, nv_state_);
-      for (std::size_t i = 0; i < y0_vars_ + args_vars_; i++) {
+          = N_VCloneVectorArrayEmpty_Serial(num_y0_vars_ + num_args_vars_, nv_state_);
+      for (std::size_t i = 0; i < num_y0_vars_ + num_args_vars_; i++) {
         NV_DATA_S(nv_state_sens_[i]) = &coupled_state_[N_] + i * N_;
       }
     }
@@ -247,8 +247,8 @@ class cvodes_integrator {
     SUNLinSolFree(LS_);
     SUNMatDestroy(A_);
     N_VDestroy_Serial(nv_state_);
-    if (y0_vars_ + args_vars_ > 0) {
-      N_VDestroyVectorArray_Serial(nv_state_sens_, y0_vars_ + args_vars_);
+    if (num_y0_vars_ + num_args_vars_ > 0) {
+      N_VDestroyVectorArray_Serial(nv_state_sens_, num_y0_vars_ + num_args_vars_);
     }
   }
 
@@ -288,9 +288,9 @@ class cvodes_integrator {
           "CVodeSetJacFn");
 
       // initialize forward sensitivity system of CVODES as needed
-      if (y0_vars_ + args_vars_ > 0) {
+      if (num_y0_vars_ + num_args_vars_ > 0) {
         check_flag_sundials(
-            CVodeSensInit(cvodes_mem, static_cast<int>(y0_vars_ + args_vars_),
+            CVodeSensInit(cvodes_mem, static_cast<int>(num_y0_vars_ + num_args_vars_),
                           CV_STAGGERED, &cvodes_integrator::cv_rhs_sens,
                           nv_state_sens_),
             "CVodeSensInit");
@@ -318,7 +318,7 @@ class cvodes_integrator {
             check_flag_sundials(error_code, "CVode");
           }
 
-          if (y0_vars_ + args_vars_ > 0) {
+          if (num_y0_vars_ + num_args_vars_ > 0) {
             check_flag_sundials(
                 CVodeGetSens(cvodes_mem, &t_init, nv_state_sens_),
                 "CVodeGetSens");
diff --git a/stan/math/rev/functor/ode_adams.hpp b/stan/math/rev/functor/ode_adams.hpp
index b32753d65d0..f02f4695ec2 100644
--- a/stan/math/rev/functor/ode_adams.hpp
+++ b/stan/math/rev/functor/ode_adams.hpp
@@ -12,8 +12,8 @@ namespace math {
 
 /**
  * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
- * times, { t1, t2, t3, ... } using the stiff backward differentiation formula
- * Adams-Moulton solver from CVODES.
+ * times, { t1, t2, t3, ... } using the non-stiff Adams-Moulton solver from
+ * CVODES.
  *
  * \p f must define an operator() with the signature as:
  *   template<typename T_t, typename T_y, typename... T_Args>
@@ -63,8 +63,8 @@ ode_adams_tol_impl(const char* function_name, const F& f,
 
 /**
  * Solve the ODE initial value problem y' = f(t, y), y(t0) = y0 at a set of
- * times, { t1, t2, t3, ... } using the stiff backward differentiation formula
- * Adams-Moulton solver from CVODES.
+ * times, { t1, t2, t3, ... } using the non-stiff Adams-Moulton solver from
+ * CVODES.
  *
  * \p f must define an operator() with the signature as:
  *   template<typename T_t, typename T_y, typename... T_Args>
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 152c3e8d9af..9bf3c07aefc 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -38,10 +38,10 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
     const Eigen::Matrix<T_y0_t0, Eigen::Dynamic, 1>& y0, const T_t0& t0,
     const T_t& t, std::ostream* msgs, const Args&... args) {
   const size_t N = y0.size();
-  const size_t y0_vars = count_vars(y0);
-  const size_t args_vars = count_vars(args...);
-  const size_t t0_vars = count_vars(t0);
-  const size_t t_vars = count_vars(t);
+  const size_t num_y0_vars = count_vars(y0);
+  const size_t num_args_vars = count_vars(args...);
+  const size_t num_t0_vars = count_vars(t0);
+  const size_t num_t_vars = count_vars(t);
   Eigen::Matrix<var, Eigen::Dynamic, 1> yt(N);
 
   Eigen::VectorXd y(N);
@@ -57,7 +57,7 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
   if (is_var<T_t0>::value)
     f_y0_t0 = f(value_of(t0), value_of(y0).eval(), msgs, value_of(args)...);
 
-  const size_t total_vars = y0_vars + args_vars + t0_vars + t_vars;
+  const size_t total_vars = num_y0_vars + num_args_vars + num_t0_vars + num_t_vars;
 
   vari** varis
       = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
@@ -72,24 +72,24 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
 
   for (size_t j = 0; j < N; ++j) {
     double* partials_j = partials + j * total_vars;
-    for (size_t k = 0; k < y0_vars; ++k) {
-      partials_j[k] = coupled_state[N + y0_vars * k + j];
+    for (size_t k = 0; k < num_y0_vars; ++k) {
+      partials_j[k] = coupled_state[N + num_y0_vars * k + j];
     }
 
-    for (size_t k = 0; k < args_vars; ++k) {
-      partials_j[y0_vars + k] = coupled_state[N + N * y0_vars + N * k + j];
+    for (size_t k = 0; k < num_args_vars; ++k) {
+      partials_j[num_y0_vars + k] = coupled_state[N + N * num_y0_vars + N * k + j];
     }
 
     if (is_var<T_t0>::value) {
       double dyt_dt0 = 0.0;
-      for (size_t k = 0; k < y0_vars; ++k) {
-        dyt_dt0 += -f_y0_t0.coeffRef(k) * coupled_state[N + y0_vars * k + j];
+      for (size_t k = 0; k < num_y0_vars; ++k) {
+        dyt_dt0 += -f_y0_t0.coeffRef(k) * coupled_state[N + num_y0_vars * k + j];
       }
-      partials_j[y0_vars + args_vars] = dyt_dt0;
+      partials_j[num_y0_vars + num_args_vars] = dyt_dt0;
     }
 
     if (is_var<T_t>::value) {
-      partials_j[y0_vars + args_vars + t0_vars] = f_y_t.coeffRef(j);
+      partials_j[num_y0_vars + num_args_vars + num_t0_vars] = f_y_t.coeffRef(j);
     }
 
     yt(j) = new precomputed_gradients_vari(y(j), total_vars, varis, partials_j);
diff --git a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
index 9b18f551ae7..d1a58730758 100644
--- a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
@@ -116,12 +116,16 @@ TEST(ode_rk45_prim, ts_errors) {
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a));
+  std::vector<Eigen::VectorXd> out;
+  EXPECT_NO_THROW(out = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a));
+  EXPECT_EQ(out.size(), ts.size());
 
-  EXPECT_NO_THROW(
-      stan::math::ode_rk45(CosArg1(), y0, t0, ts_repeat, nullptr, a));
+  EXPECT_NO_THROW(out = stan::math::ode_rk45(CosArg1(), y0, t0, ts_repeat, nullptr, a));
+  EXPECT_EQ(out.size(), ts_repeat.size());
+  EXPECT_MATRIX_FLOAT_EQ(out[0], out[1]);
 
-  EXPECT_NO_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts_lots, nullptr, a));
+  EXPECT_NO_THROW(out = stan::math::ode_rk45(CosArg1(), y0, t0, ts_lots, nullptr, a));
+  EXPECT_EQ(out.size(), ts_lots.size());
 
   EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts_empty, nullptr, a),
                std::invalid_argument);
diff --git a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
index cae41261fe9..402cd34f619 100644
--- a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
@@ -123,14 +123,19 @@ TEST(ode_rk45_tol_prim, ts_errors) {
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+  std::vector<Eigen::VectorXd> out;
+  EXPECT_NO_THROW(out = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
                                            1e6, nullptr, a));
+  EXPECT_EQ(out.size(), ts.size());
 
-  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
+  EXPECT_NO_THROW(out = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
                                            1e-10, 1e6, nullptr, a));
+  EXPECT_EQ(out.size(), ts_repeat.size());
+  EXPECT_MATRIX_FLOAT_EQ(out[0], out[1]);
 
-  EXPECT_NO_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
+  EXPECT_NO_THROW(out = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
                                            1e-10, 1e6, nullptr, a));
+  EXPECT_EQ(out.size(), ts_lots.size());
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
                                         1e-10, 1e6, nullptr, a),
@@ -426,3 +431,15 @@ TEST(ode_rk45_tol_prim, error_name) {
                                             100, nullptr, ainf),
                    std::domain_error, "ode_rk45_tol");
 }
+
+TEST(ode_rk45_tol_prim, too_much_work) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1e10};
+
+  double a = 1.0;
+
+  EXPECT_THROW_MSG(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+                                            100, nullptr, a),
+                   std::domain_error, "Failed to integrate to next output time");
+}
diff --git a/test/unit/math/rev/functor/ode_adams_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
index 5259bdd86f6..e615b380a07 100644
--- a/test/unit/math/rev/functor/ode_adams_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
@@ -116,13 +116,16 @@ TEST(ode_adams_prim, ts_errors) {
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a));
+  std::vector<Eigen::VectorXd> out;
+  EXPECT_NO_THROW(out = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a));
+  EXPECT_EQ(out.size(), ts.size());
 
-  EXPECT_NO_THROW(
-      stan::math::ode_adams(CosArg1(), y0, t0, ts_repeat, nullptr, a));
+  EXPECT_NO_THROW(out = stan::math::ode_adams(CosArg1(), y0, t0, ts_repeat, nullptr, a));
+  EXPECT_EQ(out.size(), ts_repeat.size());
+  EXPECT_MATRIX_FLOAT_EQ(out[0], out[1]);
 
-  EXPECT_NO_THROW(
-      stan::math::ode_adams(CosArg1(), y0, t0, ts_lots, nullptr, a));
+  EXPECT_NO_THROW(out = stan::math::ode_adams(CosArg1(), y0, t0, ts_lots, nullptr, a));
+  EXPECT_EQ(out.size(), ts_lots.size());
 
   EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts_empty, nullptr, a),
                std::invalid_argument);
diff --git a/test/unit/math/rev/functor/ode_adams_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
index 9409652cdda..8a1958b8d64 100644
--- a/test/unit/math/rev/functor/ode_adams_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_rev_test.cpp
@@ -143,6 +143,8 @@ TEST(StanMathOde_ode_adams, ts_repeat) {
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a);
 
+  EXPECT_EQ(output.size(), ts.size());
+
   output[0][0].grad();
 
   EXPECT_NEAR(output[0][0].val(), 0.4165982112, 1e-5);
diff --git a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
index 8e61ba88fe2..47adfd8f15c 100644
--- a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
@@ -123,14 +123,19 @@ TEST(ode_adams_tol_prim, ts_errors) {
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                            1e6, nullptr, a));
+  std::vector<Eigen::VectorXd> out;
+  EXPECT_NO_THROW(out = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, a));
+  EXPECT_EQ(out.size(), ts.size());
 
-  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
-                                            1e-10, 1e6, nullptr, a));
+  EXPECT_NO_THROW(out = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
+                                           1e-10, 1e6, nullptr, a));
+  EXPECT_EQ(out.size(), ts_repeat.size());
+  EXPECT_MATRIX_FLOAT_EQ(out[0], out[1]);
 
-  EXPECT_NO_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
-                                            1e-10, 1e6, nullptr, a));
+  EXPECT_NO_THROW(out = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
+                                           1e-10, 1e6, nullptr, a));
+  EXPECT_EQ(out.size(), ts_lots.size());
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
                                          1e-10, 1e6, nullptr, a),
@@ -426,3 +431,15 @@ TEST(ode_adams_tol_prim, error_name) {
                                              100, nullptr, ainf),
                    std::domain_error, "ode_adams_tol");
 }
+
+TEST(ode_adams_tol_prim, too_much_work) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1e10};
+
+  double a = 1.0;
+
+  EXPECT_THROW_MSG(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+					     100, nullptr, a),
+                   std::domain_error, "Failed to integrate to next output time");
+}
diff --git a/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
index 16169962b01..0d8dc105993 100644
--- a/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
@@ -1,5 +1,6 @@
 #include <stan/math/rev.hpp>
 #include <gtest/gtest.h>
+#include <test/unit/util.hpp>
 #include <iostream>
 #include <vector>
 
@@ -147,6 +148,8 @@ TEST(StanMathOde_ode_adams_tol, ts_repeat) {
       = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
                                   nullptr, a);
 
+  EXPECT_EQ(output.size(), ts.size());
+
   output[0][0].grad();
 
   EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
@@ -571,3 +574,16 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 }
+
+TEST(StanMathOde_ode_adams_tol, too_much_work) {
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0 =
+    Eigen::VectorXd::Zero(1).template cast<var>();
+  var t0 = 0;
+  std::vector<var> ts = {0.45, 1e10};
+
+  var a = 1.0;
+
+  EXPECT_THROW_MSG(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+					     100, nullptr, a),
+                   std::domain_error, "Failed to integrate to next output time");
+}
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index 66f2ce1f70d..a32c8c1e149 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -116,12 +116,16 @@ TEST(ode_bdf_prim, ts_errors) {
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a));
+  std::vector<Eigen::VectorXd> out;
+  EXPECT_NO_THROW(out = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a));
+  EXPECT_EQ(out.size(), ts.size());
 
-  EXPECT_NO_THROW(
-      stan::math::ode_bdf(CosArg1(), y0, t0, ts_repeat, nullptr, a));
+  EXPECT_NO_THROW(out = stan::math::ode_bdf(CosArg1(), y0, t0, ts_repeat, nullptr, a));
+  EXPECT_EQ(out.size(), ts_repeat.size());
+  EXPECT_MATRIX_FLOAT_EQ(out[0], out[1]);
 
-  EXPECT_NO_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts_lots, nullptr, a));
+  EXPECT_NO_THROW(out = stan::math::ode_bdf(CosArg1(), y0, t0, ts_lots, nullptr, a));
+  EXPECT_EQ(out.size(), ts_lots.size());
 
   EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts_empty, nullptr, a),
                std::invalid_argument);
diff --git a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
index bf5ec3933e0..7fc537d4185 100644
--- a/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_rev_test.cpp
@@ -143,6 +143,8 @@ TEST(StanMathOde_ode_bdf, ts_repeat) {
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a);
 
+  EXPECT_EQ(output.size(), ts.size());
+
   output[0][0].grad();
 
   EXPECT_NEAR(output[0][0].val(), 0.4165982112, 1e-5);
diff --git a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
index 3dabafcaf2e..55d514244cc 100644
--- a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
@@ -123,14 +123,19 @@ TEST(ode_bdf_tol_prim, ts_errors) {
 
   double a = 1.5;
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                          1e6, nullptr, a));
+  std::vector<Eigen::VectorXd> out;
+  EXPECT_NO_THROW(out = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
+                                           1e6, nullptr, a));
+  EXPECT_EQ(out.size(), ts.size());
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
-                                          1e-10, 1e6, nullptr, a));
+  EXPECT_NO_THROW(out = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
+                                           1e-10, 1e6, nullptr, a));
+  EXPECT_EQ(out.size(), ts_repeat.size());
+  EXPECT_MATRIX_FLOAT_EQ(out[0], out[1]);
 
-  EXPECT_NO_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
-                                          1e-10, 1e6, nullptr, a));
+  EXPECT_NO_THROW(out = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
+                                           1e-10, 1e6, nullptr, a));
+  EXPECT_EQ(out.size(), ts_lots.size());
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
                                        1e-10, 1e6, nullptr, a),
@@ -426,3 +431,15 @@ TEST(ode_bdf_tol_prim, error_name) {
                                            100, nullptr, ainf),
                    std::domain_error, "ode_bdf_tol");
 }
+
+TEST(ode_bdf_tol_prim, too_much_work) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Zero(1);
+  double t0 = 0;
+  std::vector<double> ts = {0.45, 1e10};
+
+  double a = 1.0;
+
+  EXPECT_THROW_MSG(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+					   100, nullptr, a),
+                   std::domain_error, "Failed to integrate to next output time");
+}
diff --git a/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
index da2e9cbbf20..510ed56b73b 100644
--- a/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
@@ -1,5 +1,6 @@
 #include <stan/math/rev.hpp>
 #include <gtest/gtest.h>
+#include <test/unit/util.hpp>
 #include <iostream>
 #include <vector>
 
@@ -147,6 +148,8 @@ TEST(StanMathOde_ode_bdf_tol, ts_repeat) {
       = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
                                 nullptr, a);
 
+  EXPECT_EQ(output.size(), ts.size());
+
   output[0][0].grad();
 
   EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
@@ -571,3 +574,16 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 }
+
+TEST(StanMathOde_ode_bdf_tol, too_much_work) {
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0 =
+    Eigen::VectorXd::Zero(1).template cast<var>();
+  var t0 = 0;
+  std::vector<var> ts = {0.45, 1e10};
+
+  var a = 1.0;
+
+  EXPECT_THROW_MSG(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+					   100, nullptr, a),
+                   std::domain_error, "Failed to integrate to next output time");
+}
diff --git a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
index 50d3cffdf67..40291d726f3 100644
--- a/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_rev_test.cpp
@@ -143,6 +143,8 @@ TEST(StanMathOde_ode_rk45, ts_repeat) {
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, 1>> output
       = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a);
 
+  EXPECT_EQ(output.size(), ts.size());
+
   output[0][0].grad();
 
   EXPECT_NEAR(output[0][0].val(), 0.4165982112, 1e-5);
diff --git a/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
index b678e34c623..b30e31c1138 100644
--- a/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
@@ -1,5 +1,6 @@
 #include <stan/math/rev.hpp>
 #include <gtest/gtest.h>
+#include <test/unit/util.hpp>
 #include <iostream>
 #include <vector>
 
@@ -147,6 +148,8 @@ TEST(StanMathOde_ode_rk45_tol, ts_repeat) {
       = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10, 1e6,
                                  nullptr, a);
 
+  EXPECT_EQ(output.size(), ts.size());
+
   output[0][0].grad();
 
   EXPECT_FLOAT_EQ(output[0][0].val(), 0.4165982112);
@@ -571,3 +574,16 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
   check_ts(ts);
   check_a(a);
 }
+
+TEST(StanMathOde_ode_rk45_tol, too_much_work) {
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0 =
+    Eigen::VectorXd::Zero(1).template cast<var>();
+  var t0 = 0;
+  std::vector<var> ts = {0.45, 1e10};
+
+  var a = 1.0;
+
+  EXPECT_THROW_MSG(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
+					    100, nullptr, a),
+                   std::domain_error, "Failed to integrate to next output time");
+}

From 29cde1419c585db451e4d9199c69c1d02169eb95 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Tue, 7 Jul 2020 13:42:57 -0400
Subject: [PATCH 170/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 stan/math/rev/core/accumulate_adjoints.hpp    |  3 +--
 stan/math/rev/core/save_varis.hpp             |  3 +--
 stan/math/rev/functor/coupled_ode_system.hpp  |  4 ++--
 stan/math/rev/functor/cvodes_integrator.hpp   | 13 +++++++------
 .../rev/functor/ode_store_sensitivities.hpp   |  9 ++++++---
 .../math/prim/functor/ode_rk45_prim_test.cpp  |  9 ++++++---
 .../prim/functor/ode_rk45_tol_prim_test.cpp   | 17 ++++++++++-------
 .../math/rev/functor/ode_adams_prim_test.cpp  |  9 ++++++---
 .../rev/functor/ode_adams_tol_prim_test.cpp   | 19 +++++++++++--------
 .../rev/functor/ode_adams_tol_rev_test.cpp    |  9 +++++----
 .../math/rev/functor/ode_bdf_prim_test.cpp    |  6 ++++--
 .../rev/functor/ode_bdf_tol_prim_test.cpp     | 17 +++++++++--------
 .../math/rev/functor/ode_bdf_tol_rev_test.cpp |  9 +++++----
 .../rev/functor/ode_rk45_tol_rev_test.cpp     |  9 +++++----
 14 files changed, 78 insertions(+), 58 deletions(-)

diff --git a/stan/math/rev/core/accumulate_adjoints.hpp b/stan/math/rev/core/accumulate_adjoints.hpp
index 29fd191afff..e5b27354ebd 100644
--- a/stan/math/rev/core/accumulate_adjoints.hpp
+++ b/stan/math/rev/core/accumulate_adjoints.hpp
@@ -135,8 +135,7 @@ inline double* accumulate_adjoints(double* dest, EigT&& x, Pargs&&... args) {
  * @param args Further args to accumulate over
  * @return Final position of adjoint storage pointer
  */
-template <typename Arith, require_st_arithmetic<Arith>*,
-          typename... Pargs>
+template <typename Arith, require_st_arithmetic<Arith>*, typename... Pargs>
 inline double* accumulate_adjoints(double* dest, Arith&& x, Pargs&&... args) {
   return accumulate_adjoints(dest, std::forward<Pargs>(args)...);
 }
diff --git a/stan/math/rev/core/save_varis.hpp b/stan/math/rev/core/save_varis.hpp
index a252ce5c07e..46c1f48799d 100644
--- a/stan/math/rev/core/save_varis.hpp
+++ b/stan/math/rev/core/save_varis.hpp
@@ -131,8 +131,7 @@ inline vari** save_varis(vari** dest, EigT&& x, Pargs&&... args) {
  * @param[in] args Additional arguments to have their varis saved
  * @return Final position of dest pointer
  */
-template <typename Arith, require_st_arithmetic<Arith>*,
-          typename... Pargs>
+template <typename Arith, require_st_arithmetic<Arith>*, typename... Pargs>
 inline vari** save_varis(vari** dest, Arith&& x, Pargs&&... args) {
   return save_varis(dest, std::forward<Pargs>(args)...);
 }
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index 6f6a29a55c6..8cca3882597 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -163,8 +163,8 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
       for (size_t j = 0; j < num_args_vars; ++j) {
         double temp_deriv = args_adjoints_.coeffRef(j);
         for (size_t k = 0; k < N_; ++k) {
-          temp_deriv
-              += z[N_ + N_ * num_y0_vars_ + N_ * j + k] * y_adjoints_.coeffRef(k);
+          temp_deriv += z[N_ + N_ * num_y0_vars_ + N_ * j + k]
+                        * y_adjoints_.coeffRef(k);
         }
 
         dz_dt[N_ + N_ * num_y0_vars_ + N_ * j + i] = temp_deriv;
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 3a1c31dfff2..95375400aa5 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -235,8 +235,8 @@ class cvodes_integrator {
     LS_ = SUNDenseLinearSolver(nv_state_, A_);
 
     if (num_y0_vars_ + num_args_vars_ > 0) {
-      nv_state_sens_
-          = N_VCloneVectorArrayEmpty_Serial(num_y0_vars_ + num_args_vars_, nv_state_);
+      nv_state_sens_ = N_VCloneVectorArrayEmpty_Serial(
+          num_y0_vars_ + num_args_vars_, nv_state_);
       for (std::size_t i = 0; i < num_y0_vars_ + num_args_vars_; i++) {
         NV_DATA_S(nv_state_sens_[i]) = &coupled_state_[N_] + i * N_;
       }
@@ -248,7 +248,8 @@ class cvodes_integrator {
     SUNMatDestroy(A_);
     N_VDestroy_Serial(nv_state_);
     if (num_y0_vars_ + num_args_vars_ > 0) {
-      N_VDestroyVectorArray_Serial(nv_state_sens_, num_y0_vars_ + num_args_vars_);
+      N_VDestroyVectorArray_Serial(nv_state_sens_,
+                                   num_y0_vars_ + num_args_vars_);
     }
   }
 
@@ -290,9 +291,9 @@ class cvodes_integrator {
       // initialize forward sensitivity system of CVODES as needed
       if (num_y0_vars_ + num_args_vars_ > 0) {
         check_flag_sundials(
-            CVodeSensInit(cvodes_mem, static_cast<int>(num_y0_vars_ + num_args_vars_),
-                          CV_STAGGERED, &cvodes_integrator::cv_rhs_sens,
-                          nv_state_sens_),
+            CVodeSensInit(
+                cvodes_mem, static_cast<int>(num_y0_vars_ + num_args_vars_),
+                CV_STAGGERED, &cvodes_integrator::cv_rhs_sens, nv_state_sens_),
             "CVodeSensInit");
 
         check_flag_sundials(CVodeSetSensErrCon(cvodes_mem, SUNTRUE),
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 9bf3c07aefc..3274f971fcb 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -57,7 +57,8 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
   if (is_var<T_t0>::value)
     f_y0_t0 = f(value_of(t0), value_of(y0).eval(), msgs, value_of(args)...);
 
-  const size_t total_vars = num_y0_vars + num_args_vars + num_t0_vars + num_t_vars;
+  const size_t total_vars
+      = num_y0_vars + num_args_vars + num_t0_vars + num_t_vars;
 
   vari** varis
       = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
@@ -77,13 +78,15 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
     }
 
     for (size_t k = 0; k < num_args_vars; ++k) {
-      partials_j[num_y0_vars + k] = coupled_state[N + N * num_y0_vars + N * k + j];
+      partials_j[num_y0_vars + k]
+          = coupled_state[N + N * num_y0_vars + N * k + j];
     }
 
     if (is_var<T_t0>::value) {
       double dyt_dt0 = 0.0;
       for (size_t k = 0; k < num_y0_vars; ++k) {
-        dyt_dt0 += -f_y0_t0.coeffRef(k) * coupled_state[N + num_y0_vars * k + j];
+        dyt_dt0
+            += -f_y0_t0.coeffRef(k) * coupled_state[N + num_y0_vars * k + j];
       }
       partials_j[num_y0_vars + num_args_vars] = dyt_dt0;
     }
diff --git a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
index d1a58730758..848b8aad112 100644
--- a/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_prim_test.cpp
@@ -117,14 +117,17 @@ TEST(ode_rk45_prim, ts_errors) {
   double a = 1.5;
 
   std::vector<Eigen::VectorXd> out;
-  EXPECT_NO_THROW(out = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a));
+  EXPECT_NO_THROW(out
+                  = stan::math::ode_rk45(CosArg1(), y0, t0, ts, nullptr, a));
   EXPECT_EQ(out.size(), ts.size());
 
-  EXPECT_NO_THROW(out = stan::math::ode_rk45(CosArg1(), y0, t0, ts_repeat, nullptr, a));
+  EXPECT_NO_THROW(
+      out = stan::math::ode_rk45(CosArg1(), y0, t0, ts_repeat, nullptr, a));
   EXPECT_EQ(out.size(), ts_repeat.size());
   EXPECT_MATRIX_FLOAT_EQ(out[0], out[1]);
 
-  EXPECT_NO_THROW(out = stan::math::ode_rk45(CosArg1(), y0, t0, ts_lots, nullptr, a));
+  EXPECT_NO_THROW(
+      out = stan::math::ode_rk45(CosArg1(), y0, t0, ts_lots, nullptr, a));
   EXPECT_EQ(out.size(), ts_lots.size());
 
   EXPECT_THROW(stan::math::ode_rk45(CosArg1(), y0, t0, ts_empty, nullptr, a),
diff --git a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
index 402cd34f619..b6d87c055a6 100644
--- a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
@@ -124,17 +124,19 @@ TEST(ode_rk45_tol_prim, ts_errors) {
   double a = 1.5;
 
   std::vector<Eigen::VectorXd> out;
-  EXPECT_NO_THROW(out = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a));
+  EXPECT_NO_THROW(out = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-10,
+                                                 1e-10, 1e6, nullptr, a));
   EXPECT_EQ(out.size(), ts.size());
 
-  EXPECT_NO_THROW(out = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
-                                           1e-10, 1e6, nullptr, a));
+  EXPECT_NO_THROW(out
+                  = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_repeat,
+                                             1e-10, 1e-10, 1e6, nullptr, a));
   EXPECT_EQ(out.size(), ts_repeat.size());
   EXPECT_MATRIX_FLOAT_EQ(out[0], out[1]);
 
-  EXPECT_NO_THROW(out = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
-                                           1e-10, 1e6, nullptr, a));
+  EXPECT_NO_THROW(out
+                  = stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
+                                             1e-10, 1e6, nullptr, a));
   EXPECT_EQ(out.size(), ts_lots.size());
 
   EXPECT_THROW(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
@@ -441,5 +443,6 @@ TEST(ode_rk45_tol_prim, too_much_work) {
 
   EXPECT_THROW_MSG(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
                                             100, nullptr, a),
-                   std::domain_error, "Failed to integrate to next output time");
+                   std::domain_error,
+                   "Failed to integrate to next output time");
 }
diff --git a/test/unit/math/rev/functor/ode_adams_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
index e615b380a07..5476aea7da2 100644
--- a/test/unit/math/rev/functor/ode_adams_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_prim_test.cpp
@@ -117,14 +117,17 @@ TEST(ode_adams_prim, ts_errors) {
   double a = 1.5;
 
   std::vector<Eigen::VectorXd> out;
-  EXPECT_NO_THROW(out = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a));
+  EXPECT_NO_THROW(out
+                  = stan::math::ode_adams(CosArg1(), y0, t0, ts, nullptr, a));
   EXPECT_EQ(out.size(), ts.size());
 
-  EXPECT_NO_THROW(out = stan::math::ode_adams(CosArg1(), y0, t0, ts_repeat, nullptr, a));
+  EXPECT_NO_THROW(
+      out = stan::math::ode_adams(CosArg1(), y0, t0, ts_repeat, nullptr, a));
   EXPECT_EQ(out.size(), ts_repeat.size());
   EXPECT_MATRIX_FLOAT_EQ(out[0], out[1]);
 
-  EXPECT_NO_THROW(out = stan::math::ode_adams(CosArg1(), y0, t0, ts_lots, nullptr, a));
+  EXPECT_NO_THROW(
+      out = stan::math::ode_adams(CosArg1(), y0, t0, ts_lots, nullptr, a));
   EXPECT_EQ(out.size(), ts_lots.size());
 
   EXPECT_THROW(stan::math::ode_adams(CosArg1(), y0, t0, ts_empty, nullptr, a),
diff --git a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
index 47adfd8f15c..b8c2bc8158b 100644
--- a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
@@ -124,17 +124,19 @@ TEST(ode_adams_tol_prim, ts_errors) {
   double a = 1.5;
 
   std::vector<Eigen::VectorXd> out;
-  EXPECT_NO_THROW(out = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a));
+  EXPECT_NO_THROW(out = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10,
+                                                  1e-10, 1e6, nullptr, a));
   EXPECT_EQ(out.size(), ts.size());
 
-  EXPECT_NO_THROW(out = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
-                                           1e-10, 1e6, nullptr, a));
+  EXPECT_NO_THROW(out
+                  = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_repeat,
+                                              1e-10, 1e-10, 1e6, nullptr, a));
   EXPECT_EQ(out.size(), ts_repeat.size());
   EXPECT_MATRIX_FLOAT_EQ(out[0], out[1]);
 
-  EXPECT_NO_THROW(out = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
-                                           1e-10, 1e6, nullptr, a));
+  EXPECT_NO_THROW(out
+                  = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
+                                              1e-10, 1e6, nullptr, a));
   EXPECT_EQ(out.size(), ts_lots.size());
 
   EXPECT_THROW(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
@@ -440,6 +442,7 @@ TEST(ode_adams_tol_prim, too_much_work) {
   double a = 1.0;
 
   EXPECT_THROW_MSG(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-					     100, nullptr, a),
-                   std::domain_error, "Failed to integrate to next output time");
+                                             100, nullptr, a),
+                   std::domain_error,
+                   "Failed to integrate to next output time");
 }
diff --git a/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
index 0d8dc105993..93e50740061 100644
--- a/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
@@ -576,14 +576,15 @@ TEST(StanMathOde_ode_adams_tol, arg_combos_test) {
 }
 
 TEST(StanMathOde_ode_adams_tol, too_much_work) {
-  Eigen::Matrix<var, Eigen::Dynamic, 1> y0 =
-    Eigen::VectorXd::Zero(1).template cast<var>();
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0
+      = Eigen::VectorXd::Zero(1).template cast<var>();
   var t0 = 0;
   std::vector<var> ts = {0.45, 1e10};
 
   var a = 1.0;
 
   EXPECT_THROW_MSG(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-					     100, nullptr, a),
-                   std::domain_error, "Failed to integrate to next output time");
+                                             100, nullptr, a),
+                   std::domain_error,
+                   "Failed to integrate to next output time");
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
index a32c8c1e149..8afd89965ab 100644
--- a/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_prim_test.cpp
@@ -120,11 +120,13 @@ TEST(ode_bdf_prim, ts_errors) {
   EXPECT_NO_THROW(out = stan::math::ode_bdf(CosArg1(), y0, t0, ts, nullptr, a));
   EXPECT_EQ(out.size(), ts.size());
 
-  EXPECT_NO_THROW(out = stan::math::ode_bdf(CosArg1(), y0, t0, ts_repeat, nullptr, a));
+  EXPECT_NO_THROW(
+      out = stan::math::ode_bdf(CosArg1(), y0, t0, ts_repeat, nullptr, a));
   EXPECT_EQ(out.size(), ts_repeat.size());
   EXPECT_MATRIX_FLOAT_EQ(out[0], out[1]);
 
-  EXPECT_NO_THROW(out = stan::math::ode_bdf(CosArg1(), y0, t0, ts_lots, nullptr, a));
+  EXPECT_NO_THROW(
+      out = stan::math::ode_bdf(CosArg1(), y0, t0, ts_lots, nullptr, a));
   EXPECT_EQ(out.size(), ts_lots.size());
 
   EXPECT_THROW(stan::math::ode_bdf(CosArg1(), y0, t0, ts_empty, nullptr, a),
diff --git a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
index 55d514244cc..dde9446c438 100644
--- a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
@@ -124,17 +124,17 @@ TEST(ode_bdf_tol_prim, ts_errors) {
   double a = 1.5;
 
   std::vector<Eigen::VectorXd> out;
-  EXPECT_NO_THROW(out = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10, 1e-10,
-                                           1e6, nullptr, a));
+  EXPECT_NO_THROW(out = stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-10,
+                                                  1e-10, 1e6, nullptr, a));
   EXPECT_EQ(out.size(), ts.size());
 
-  EXPECT_NO_THROW(out = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_repeat, 1e-10,
-                                           1e-10, 1e6, nullptr, a));
+  EXPECT_NO_THROW(out = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_repeat,
+                                                1e-10, 1e-10, 1e6, nullptr, a));
   EXPECT_EQ(out.size(), ts_repeat.size());
   EXPECT_MATRIX_FLOAT_EQ(out[0], out[1]);
 
-  EXPECT_NO_THROW(out = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_lots, 1e-10,
-                                           1e-10, 1e6, nullptr, a));
+  EXPECT_NO_THROW(out = stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_lots,
+                                                1e-10, 1e-10, 1e6, nullptr, a));
   EXPECT_EQ(out.size(), ts_lots.size());
 
   EXPECT_THROW(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts_empty, 1e-10,
@@ -440,6 +440,7 @@ TEST(ode_bdf_tol_prim, too_much_work) {
   double a = 1.0;
 
   EXPECT_THROW_MSG(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-					   100, nullptr, a),
-                   std::domain_error, "Failed to integrate to next output time");
+                                           100, nullptr, a),
+                   std::domain_error,
+                   "Failed to integrate to next output time");
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
index 510ed56b73b..1aec32ab9cc 100644
--- a/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
@@ -576,14 +576,15 @@ TEST(StanMathOde_ode_bdf_tol, arg_combos_test) {
 }
 
 TEST(StanMathOde_ode_bdf_tol, too_much_work) {
-  Eigen::Matrix<var, Eigen::Dynamic, 1> y0 =
-    Eigen::VectorXd::Zero(1).template cast<var>();
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0
+      = Eigen::VectorXd::Zero(1).template cast<var>();
   var t0 = 0;
   std::vector<var> ts = {0.45, 1e10};
 
   var a = 1.0;
 
   EXPECT_THROW_MSG(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-					   100, nullptr, a),
-                   std::domain_error, "Failed to integrate to next output time");
+                                           100, nullptr, a),
+                   std::domain_error,
+                   "Failed to integrate to next output time");
 }
diff --git a/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
index b30e31c1138..05bb245c1e1 100644
--- a/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
@@ -576,14 +576,15 @@ TEST(StanMathOde_ode_rk45_tol, arg_combos_test) {
 }
 
 TEST(StanMathOde_ode_rk45_tol, too_much_work) {
-  Eigen::Matrix<var, Eigen::Dynamic, 1> y0 =
-    Eigen::VectorXd::Zero(1).template cast<var>();
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0
+      = Eigen::VectorXd::Zero(1).template cast<var>();
   var t0 = 0;
   std::vector<var> ts = {0.45, 1e10};
 
   var a = 1.0;
 
   EXPECT_THROW_MSG(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
-					    100, nullptr, a),
-                   std::domain_error, "Failed to integrate to next output time");
+                                            100, nullptr, a),
+                   std::domain_error,
+                   "Failed to integrate to next output time");
 }

From 35267b1ed8ded7e7cf6e928583f734d38834ae78 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Tue, 7 Jul 2020 18:30:35 -0400
Subject: [PATCH 171/189] Added ode_store_sensitivities tests (design-doc #19)

---
 .../functor/ode_store_sensitivities_test.cpp  | 31 +++++++
 .../functor/ode_store_sensitivities_test.cpp  | 87 +++++++++++++++++++
 2 files changed, 118 insertions(+)
 create mode 100644 test/unit/math/prim/functor/ode_store_sensitivities_test.cpp
 create mode 100644 test/unit/math/rev/functor/ode_store_sensitivities_test.cpp

diff --git a/test/unit/math/prim/functor/ode_store_sensitivities_test.cpp b/test/unit/math/prim/functor/ode_store_sensitivities_test.cpp
new file mode 100644
index 00000000000..8be92d42b1c
--- /dev/null
+++ b/test/unit/math/prim/functor/ode_store_sensitivities_test.cpp
@@ -0,0 +1,31 @@
+#include <stan/math/prim.hpp>
+#include <gtest/gtest.h>
+#include <test/unit/util.hpp>
+#include <test/unit/math/prim/functor/mock_ode_functor.hpp>
+#include <vector>
+#include <string>
+
+TEST(MathPrim, ode_store_sensitivities) {
+  mock_ode_functor base_ode;
+
+  size_t N = 5;
+
+  int ignored1 = 0;
+  double ignored2 = 0.0;
+  Eigen::VectorXd ignored3;
+  std::vector<std::vector<double>> ignored4;
+
+  std::vector<double> coupled_state(N);
+  for(size_t i = 0; i < coupled_state.size(); ++i)
+    coupled_state[i] = i + 1;
+
+  Eigen::VectorXd output =
+    stan::math::ode_store_sensitivities(base_ode, coupled_state,
+					Eigen::VectorXd::Ones(3).eval(),
+					0, 0.0, nullptr,
+					ignored1, ignored2,
+					ignored3, ignored4);
+
+  EXPECT_EQ(output.size(), coupled_state.size());
+  EXPECT_MATRIX_FLOAT_EQ(output, stan::math::to_vector(coupled_state).eval());
+}
diff --git a/test/unit/math/rev/functor/ode_store_sensitivities_test.cpp b/test/unit/math/rev/functor/ode_store_sensitivities_test.cpp
new file mode 100644
index 00000000000..6ca3aa4d5f1
--- /dev/null
+++ b/test/unit/math/rev/functor/ode_store_sensitivities_test.cpp
@@ -0,0 +1,87 @@
+#include <stan/math/rev.hpp>
+#include <gtest/gtest.h>
+#include <test/unit/util.hpp>
+#include <vector>
+#include <string>
+
+template <typename T, stan::require_stan_scalar_t<T>* = nullptr>
+T sum_(T arg) {
+  return arg;
+}
+
+template <typename EigMat, stan::require_eigen_t<EigMat>* = nullptr>
+auto sum_(EigMat&& arg) {
+  return stan::math::sum(arg);
+}
+
+template <typename Vec, stan::require_std_vector_t<Vec>* = nullptr>
+auto sum_(Vec&& arg) {
+  stan::scalar_type_t<Vec> sum = 0;
+  for (size_t i = 0; i < arg.size(); ++i) {
+    sum += sum_(arg[i]);
+  }
+  return sum;
+}
+
+struct ayt {
+  template <typename T0, typename T_y, typename... T_Args>
+  inline auto operator()(const T0& t, const T_y& y, std::ostream* msgs,
+                         const T_Args&... args) const {
+    std::vector<typename stan::return_type<T_Args...>::type> vec
+        = {sum_(args)...};
+    Eigen::Matrix<stan::return_type_t<T0, T_y, T_Args...>, Eigen::Dynamic, 1>
+        out(2);
+    out(0) = -sum_(vec) * y(0) * t;
+    out(1) = -1.7 * sum_(vec) * y(1) * t;
+    return out;
+  }
+};
+
+TEST(AgradRev, ode_store_sensitivities) {
+  using stan::math::coupled_ode_system;
+  using stan::math::var;
+
+  Eigen::VectorXd y0(2);
+  y0 << 0.1, 0.2;
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0v = y0.template cast<var>();
+
+  double a = 1.3;
+  var av = a;
+
+  ayt func;
+
+  double t0 = 0.5;
+  double t = 0.75;
+
+  var t0v = t0;
+  var tv = t;
+
+  std::vector<double> coupled_state = { -0.0975, -0.3315, -3.12000, -5.46975,
+					-4.29000, -7.45875, -2.1225, -3.9015 };
+
+  auto output = stan::math::ode_store_sensitivities(func, coupled_state,
+						    y0v, t0v, tv, nullptr,
+						    av);
+
+  output(0).grad();
+
+  EXPECT_FLOAT_EQ(output(0).val(), -0.0975);
+  EXPECT_FLOAT_EQ(y0v(0).adj(), -3.12);
+  EXPECT_FLOAT_EQ(y0v(1).adj(), -4.29);
+  EXPECT_FLOAT_EQ(av.adj(), -2.1225);
+  EXPECT_FLOAT_EQ(t0v.adj(), -1.15089);
+  EXPECT_FLOAT_EQ(tv.adj(), 0.0950625);
+
+  stan::math::set_zero_all_adjoints();
+
+  output(1).grad();
+
+  EXPECT_FLOAT_EQ(output(1).val(), -0.3315);
+  EXPECT_FLOAT_EQ(y0v(0).adj(), -5.46975);
+  EXPECT_FLOAT_EQ(y0v(1).adj(), -7.45875);
+  EXPECT_FLOAT_EQ(av.adj(), -3.9015);
+  EXPECT_FLOAT_EQ(t0v.adj(), -2.003918);
+  EXPECT_FLOAT_EQ(tv.adj(), 0.5494613);
+
+  stan::math::recover_memory();
+}

From 46465932d90afbd63bc7c7a9c9e49758515504ef Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Tue, 7 Jul 2020 18:31:54 -0400
Subject: [PATCH 172/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 .../prim/functor/ode_store_sensitivities_test.cpp     | 11 ++++-------
 .../math/rev/functor/ode_store_sensitivities_test.cpp |  9 ++++-----
 2 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/test/unit/math/prim/functor/ode_store_sensitivities_test.cpp b/test/unit/math/prim/functor/ode_store_sensitivities_test.cpp
index 8be92d42b1c..acef36e6884 100644
--- a/test/unit/math/prim/functor/ode_store_sensitivities_test.cpp
+++ b/test/unit/math/prim/functor/ode_store_sensitivities_test.cpp
@@ -16,15 +16,12 @@ TEST(MathPrim, ode_store_sensitivities) {
   std::vector<std::vector<double>> ignored4;
 
   std::vector<double> coupled_state(N);
-  for(size_t i = 0; i < coupled_state.size(); ++i)
+  for (size_t i = 0; i < coupled_state.size(); ++i)
     coupled_state[i] = i + 1;
 
-  Eigen::VectorXd output =
-    stan::math::ode_store_sensitivities(base_ode, coupled_state,
-					Eigen::VectorXd::Ones(3).eval(),
-					0, 0.0, nullptr,
-					ignored1, ignored2,
-					ignored3, ignored4);
+  Eigen::VectorXd output = stan::math::ode_store_sensitivities(
+      base_ode, coupled_state, Eigen::VectorXd::Ones(3).eval(), 0, 0.0, nullptr,
+      ignored1, ignored2, ignored3, ignored4);
 
   EXPECT_EQ(output.size(), coupled_state.size());
   EXPECT_MATRIX_FLOAT_EQ(output, stan::math::to_vector(coupled_state).eval());
diff --git a/test/unit/math/rev/functor/ode_store_sensitivities_test.cpp b/test/unit/math/rev/functor/ode_store_sensitivities_test.cpp
index 6ca3aa4d5f1..c76546b438f 100644
--- a/test/unit/math/rev/functor/ode_store_sensitivities_test.cpp
+++ b/test/unit/math/rev/functor/ode_store_sensitivities_test.cpp
@@ -56,12 +56,11 @@ TEST(AgradRev, ode_store_sensitivities) {
   var t0v = t0;
   var tv = t;
 
-  std::vector<double> coupled_state = { -0.0975, -0.3315, -3.12000, -5.46975,
-					-4.29000, -7.45875, -2.1225, -3.9015 };
+  std::vector<double> coupled_state = {-0.0975,  -0.3315,  -3.12000, -5.46975,
+                                       -4.29000, -7.45875, -2.1225,  -3.9015};
 
-  auto output = stan::math::ode_store_sensitivities(func, coupled_state,
-						    y0v, t0v, tv, nullptr,
-						    av);
+  auto output = stan::math::ode_store_sensitivities(func, coupled_state, y0v,
+                                                    t0v, tv, nullptr, av);
 
   output(0).grad();
 

From 19e029c700442ded4727edc56750c5a30b50ad02 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Wed, 8 Jul 2020 19:30:43 -0400
Subject: [PATCH 173/189] Responding to reviews (design-doc #19)

---
 stan/math/prim/fun/value_of.hpp                   |  5 +++--
 stan/math/prim/functor/coupled_ode_system.hpp     | 12 +++++++-----
 stan/math/prim/functor/integrate_ode_rk45.hpp     |  2 +-
 stan/math/prim/functor/ode_rk45.hpp               |  2 +-
 stan/math/rev/core/grad.hpp                       |  5 ++---
 stan/math/rev/functor/ode_store_sensitivities.hpp |  8 ++------
 test/unit/math/rev/core/grad_test.cpp             |  6 ------
 7 files changed, 16 insertions(+), 24 deletions(-)

diff --git a/stan/math/prim/fun/value_of.hpp b/stan/math/prim/fun/value_of.hpp
index 1cfc9aeac39..4bfae8652d7 100644
--- a/stan/math/prim/fun/value_of.hpp
+++ b/stan/math/prim/fun/value_of.hpp
@@ -34,8 +34,9 @@ template <typename T, require_not_st_arithmetic<T>* = nullptr>
 inline auto value_of(const std::vector<T>& x) {
   std::vector<plain_type_t<decltype(value_of(std::declval<T>()))>> out;
   out.reserve(x.size());
-  for (size_t n = 0; n < x.size(); ++n)
-    out.emplace_back(value_of(x[n]));
+  for (auto&& x_iter : x) {
+    out.emplace_back(value_of(x_iter));
+  }
   return out;
 }
 
diff --git a/stan/math/prim/functor/coupled_ode_system.hpp b/stan/math/prim/functor/coupled_ode_system.hpp
index 007446a7900..a4dbe69603d 100644
--- a/stan/math/prim/functor/coupled_ode_system.hpp
+++ b/stan/math/prim/functor/coupled_ode_system.hpp
@@ -56,21 +56,23 @@ struct coupled_ode_system_impl<true, F, T_y0, Args...> {
    * @param[in] z State of coupled system
    * @param[out] dz_dt Evaluation of right hand side of coupled system
    * @param[in] t Time at which to evaluated right hand side
+   * @throw exception if the system function does not return
+   * the expected number of derivatives, N.
    */
   void operator()(const std::vector<double>& z, std::vector<double>& dz_dt,
                   double t) const {
-    Eigen::VectorXd y(N_);
-    for (size_t n = 0; n < N_; ++n)
+    Eigen::VectorXd y(z.size());
+    for (size_t n = 0; n < z.size(); ++n)
       y.coeffRef(n) = z[n];
 
-    dz_dt.resize(N_);
+    dz_dt.resize(y.size());
 
     Eigen::VectorXd f_y_t
         = apply([&](const Args&... args) { return f_(t, y, msgs_, args...); },
                 args_tuple_);
 
-    check_size_match("coupled_ode_system", "y", y.size(), "dz_dt",
-                     f_y_t.size());
+    check_size_match("coupled_ode_system", "dy_dt", f_y_t.size(), "states",
+                     y.size());
 
     Eigen::Map<Eigen::VectorXd>(dz_dt.data(), dz_dt.size()) = f_y_t;
   }
diff --git a/stan/math/prim/functor/integrate_ode_rk45.hpp b/stan/math/prim/functor/integrate_ode_rk45.hpp
index f676051e448..95042febdd7 100644
--- a/stan/math/prim/functor/integrate_ode_rk45.hpp
+++ b/stan/math/prim/functor/integrate_ode_rk45.hpp
@@ -15,7 +15,7 @@ namespace math {
  */
 template <typename F, typename T_y0, typename T_param, typename T_t0,
           typename T_ts>
-std::vector<std::vector<return_type_t<T_y0, T_t0, T_ts, T_param>>>
+inline auto
 integrate_ode_rk45(const F& f, const std::vector<T_y0>& y0, const T_t0& t0,
                    const std::vector<T_ts>& ts,
                    const std::vector<T_param>& theta,
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index d0b561d503e..9f97d8cf41b 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -78,7 +78,7 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
 
   // Code from https://stackoverflow.com/a/17340003
   std::vector<int> unused_temp{
-      0, (check_finite(function_name, "ode parameters and data", args), 0)...};
+    0, (check_finite(function_name, "ode parameters and data", args), 0)...};
 
   check_nonzero_size(function_name, "initial state", y0);
   check_nonzero_size(function_name, "times", ts);
diff --git a/stan/math/rev/core/grad.hpp b/stan/math/rev/core/grad.hpp
index df644615353..01b3b153fcc 100644
--- a/stan/math/rev/core/grad.hpp
+++ b/stan/math/rev/core/grad.hpp
@@ -27,9 +27,8 @@ namespace math {
  * @param vi Variable implementation for root of partial
  * derivative propagation.
  */
-static void grad(vari* vi = NULL) {
-  if (vi != NULL)
-    vi->init_dependent();
+static void grad(vari* vi) {
+  vi->init_dependent();
   std::vector<vari*>& var_stack = ChainableStack::instance_->var_stack_;
   size_t end = var_stack.size();
   size_t beginning = empty_nested() ? 0 : end - nested_size();
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 3274f971fcb..4e991678d34 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -65,11 +65,7 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
   double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(
       N * total_vars);
 
-  vari** varis_ptr = varis;
-  varis_ptr = save_varis(varis_ptr, y0);
-  varis_ptr = save_varis(varis_ptr, args...);
-  varis_ptr = save_varis(varis_ptr, t0);
-  varis_ptr = save_varis(varis_ptr, t);
+  save_varis(varis, y0, args..., t0, t);
 
   for (size_t j = 0; j < N; ++j) {
     double* partials_j = partials + j * total_vars;
@@ -86,7 +82,7 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
       double dyt_dt0 = 0.0;
       for (size_t k = 0; k < num_y0_vars; ++k) {
         dyt_dt0
-            += -f_y0_t0.coeffRef(k) * coupled_state[N + num_y0_vars * k + j];
+	  -= f_y0_t0.coeffRef(k) * coupled_state[N + num_y0_vars * k + j];
       }
       partials_j[num_y0_vars + num_args_vars] = dyt_dt0;
     }
diff --git a/test/unit/math/rev/core/grad_test.cpp b/test/unit/math/rev/core/grad_test.cpp
index bf037794ad9..9446f8779f1 100644
--- a/test/unit/math/rev/core/grad_test.cpp
+++ b/test/unit/math/rev/core/grad_test.cpp
@@ -4,12 +4,6 @@
 #include <stan/math/rev/fun/sin.hpp>
 #include <vector>
 
-TEST(AgradRev, grad_no_argument) {
-  AVAR d = 2.0;
-  d = 2 * d;
-  stan::math::grad();
-}
-
 TEST(AgradRev, multiple_grads) {
   for (int i = 0; i < 100; ++i) {
     AVAR a = 2.0;

From 7a42c5a7f98ca67c4199e1ea0237ac3864670c36 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Wed, 8 Jul 2020 19:34:22 -0400
Subject: [PATCH 174/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 stan/math/prim/functor/integrate_ode_rk45.hpp     | 14 ++++++--------
 stan/math/prim/functor/ode_rk45.hpp               |  2 +-
 stan/math/rev/functor/ode_store_sensitivities.hpp |  3 +--
 3 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/stan/math/prim/functor/integrate_ode_rk45.hpp b/stan/math/prim/functor/integrate_ode_rk45.hpp
index 95042febdd7..1e568d6b1ea 100644
--- a/stan/math/prim/functor/integrate_ode_rk45.hpp
+++ b/stan/math/prim/functor/integrate_ode_rk45.hpp
@@ -15,14 +15,12 @@ namespace math {
  */
 template <typename F, typename T_y0, typename T_param, typename T_t0,
           typename T_ts>
-inline auto
-integrate_ode_rk45(const F& f, const std::vector<T_y0>& y0, const T_t0& t0,
-                   const std::vector<T_ts>& ts,
-                   const std::vector<T_param>& theta,
-                   const std::vector<double>& x, const std::vector<int>& x_int,
-                   std::ostream* msgs = nullptr,
-                   double relative_tolerance = 1e-6,
-                   double absolute_tolerance = 1e-6, int max_num_steps = 1e6) {
+inline auto integrate_ode_rk45(
+    const F& f, const std::vector<T_y0>& y0, const T_t0& t0,
+    const std::vector<T_ts>& ts, const std::vector<T_param>& theta,
+    const std::vector<double>& x, const std::vector<int>& x_int,
+    std::ostream* msgs = nullptr, double relative_tolerance = 1e-6,
+    double absolute_tolerance = 1e-6, int max_num_steps = 1e6) {
   internal::integrate_ode_std_vector_interface_adapter<F> f_adapted(f);
   auto y = ode_rk45_tol_impl("integrate_ode_rk45", f_adapted, to_vector(y0), t0,
                              ts, relative_tolerance, absolute_tolerance,
diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index 9f97d8cf41b..d0b561d503e 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -78,7 +78,7 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
 
   // Code from https://stackoverflow.com/a/17340003
   std::vector<int> unused_temp{
-    0, (check_finite(function_name, "ode parameters and data", args), 0)...};
+      0, (check_finite(function_name, "ode parameters and data", args), 0)...};
 
   check_nonzero_size(function_name, "initial state", y0);
   check_nonzero_size(function_name, "times", ts);
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 4e991678d34..31c3f63a5c1 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -81,8 +81,7 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
     if (is_var<T_t0>::value) {
       double dyt_dt0 = 0.0;
       for (size_t k = 0; k < num_y0_vars; ++k) {
-        dyt_dt0
-	  -= f_y0_t0.coeffRef(k) * coupled_state[N + num_y0_vars * k + j];
+        dyt_dt0 -= f_y0_t0.coeffRef(k) * coupled_state[N + num_y0_vars * k + j];
       }
       partials_j[num_y0_vars + num_args_vars] = dyt_dt0;
     }

From 3e7abbf23afcabf863040c04b3e3734eac2a8391 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Thu, 9 Jul 2020 13:55:52 -0400
Subject: [PATCH 175/189] Updated variable naming/docs (design-doc #19)

---
 stan/math/prim/fun/value_of.hpp                   | 4 ++--
 stan/math/rev/core/deep_copy_vars.hpp             | 2 +-
 stan/math/rev/functor/ode_store_sensitivities.hpp | 1 +
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/stan/math/prim/fun/value_of.hpp b/stan/math/prim/fun/value_of.hpp
index 4bfae8652d7..8cc47e80025 100644
--- a/stan/math/prim/fun/value_of.hpp
+++ b/stan/math/prim/fun/value_of.hpp
@@ -34,8 +34,8 @@ template <typename T, require_not_st_arithmetic<T>* = nullptr>
 inline auto value_of(const std::vector<T>& x) {
   std::vector<plain_type_t<decltype(value_of(std::declval<T>()))>> out;
   out.reserve(x.size());
-  for (auto&& x_iter : x) {
-    out.emplace_back(value_of(x_iter));
+  for (auto&& x_elem : x) {
+    out.emplace_back(value_of(x_elem));
   }
   return out;
 }
diff --git a/stan/math/rev/core/deep_copy_vars.hpp b/stan/math/rev/core/deep_copy_vars.hpp
index 70dc3b66e99..f73a750cf0f 100644
--- a/stan/math/rev/core/deep_copy_vars.hpp
+++ b/stan/math/rev/core/deep_copy_vars.hpp
@@ -12,7 +12,7 @@ namespace stan {
 namespace math {
 
 /**
- * Forward arguments that do not contain vars. There
+ * Pass through const references to arguments that do not contain vars. There
  *   is no copying to be done.
  *
  * @tparam Arith an arithmetic type.
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 4e991678d34..dff5f788fab 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -68,6 +68,7 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
   save_varis(varis, y0, args..., t0, t);
 
   for (size_t j = 0; j < N; ++j) {
+    // Point to memory allocated in partials to store the derivatives
     double* partials_j = partials + j * total_vars;
     for (size_t k = 0; k < num_y0_vars; ++k) {
       partials_j[k] = coupled_state[N + num_y0_vars * k + j];

From 54de59b3412f203be07f38131f1a8727bfe025b8 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Thu, 9 Jul 2020 15:10:31 -0400
Subject: [PATCH 176/189] Added some comments around strange code.

Made deep_copy_vars do perfect forwarding again. (design-doc #19)
---
 stan/math/rev/core/deep_copy_vars.hpp           |  6 +++---
 stan/math/rev/functor/coupled_ode_system.hpp    | 10 +++++++++-
 .../rev/functor/ode_store_sensitivities.hpp     | 17 +++++++++--------
 3 files changed, 21 insertions(+), 12 deletions(-)

diff --git a/stan/math/rev/core/deep_copy_vars.hpp b/stan/math/rev/core/deep_copy_vars.hpp
index f73a750cf0f..5eb1b3d8542 100644
--- a/stan/math/rev/core/deep_copy_vars.hpp
+++ b/stan/math/rev/core/deep_copy_vars.hpp
@@ -12,7 +12,7 @@ namespace stan {
 namespace math {
 
 /**
- * Pass through const references to arguments that do not contain vars. There
+ * Forward arguments that do not contain vars. There
  *   is no copying to be done.
  *
  * @tparam Arith an arithmetic type.
@@ -20,8 +20,8 @@ namespace math {
  *  Otherwise it will be moved.
  */
 template <typename Arith, typename = require_arithmetic_t<scalar_type_t<Arith>>>
-inline const Arith& deep_copy_vars(const Arith& arg) {
-  return arg;
+inline decltype(auto) deep_copy_vars(Arith&& arg) {
+  return std::forward<Arith>(arg);
 }
 
 /**
diff --git a/stan/math/rev/functor/coupled_ode_system.hpp b/stan/math/rev/functor/coupled_ode_system.hpp
index 8cca3882597..ac278e7665b 100644
--- a/stan/math/rev/functor/coupled_ode_system.hpp
+++ b/stan/math/rev/functor/coupled_ode_system.hpp
@@ -67,7 +67,7 @@ template <typename F, typename T_y0, typename... Args>
 struct coupled_ode_system_impl<false, F, T_y0, Args...> {
   const F& f_;
   const Eigen::Matrix<T_y0, Eigen::Dynamic, 1>& y0_;
-  std::tuple<decltype(deep_copy_vars(std::declval<Args>()))...>
+  std::tuple<decltype(deep_copy_vars(std::declval<const Args&>()))...>
       local_args_tuple_;
   const size_t num_y0_vars_;
   const size_t num_args_vars;
@@ -137,13 +137,17 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
 
       y_adjoints_ = y_vars.adj();
 
+      // memset was faster than Eigen setZero
       memset(args_adjoints_.data(), 0, sizeof(double) * num_args_vars);
+
       apply(
           [&](auto&&... args) {
             accumulate_adjoints(args_adjoints_.data(), args...);
           },
           local_args_tuple_);
 
+      // The vars here do not live on the nested stack so must be zero'd
+      // separately
       apply([&](auto&&... args) { zero_adjoints(args...); }, local_args_tuple_);
 
       // No need to zero adjoints after last sweep
@@ -151,6 +155,8 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
         nested.set_zero_all_adjoints();
       }
 
+      // Compute the right hand side for the sensitivities with respect to the
+      // initial conditions
       for (size_t j = 0; j < num_y0_vars_; ++j) {
         double temp_deriv = 0.0;
         for (size_t k = 0; k < N_; ++k) {
@@ -160,6 +166,8 @@ struct coupled_ode_system_impl<false, F, T_y0, Args...> {
         dz_dt[N_ + N_ * j + i] = temp_deriv;
       }
 
+      // Compute the right hand size for the sensitivities with respect to the
+      // parameters
       for (size_t j = 0; j < num_args_vars; ++j) {
         double temp_deriv = args_adjoints_.coeffRef(j);
         for (size_t k = 0; k < N_; ++k) {
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 98240b7043a..753f523c93b 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -62,20 +62,20 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
 
   vari** varis
       = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
-  double* partials = ChainableStack::instance_->memalloc_.alloc_array<double>(
+  // partials is a column major Jacobian
+  double* jacobian_mem = ChainableStack::instance_->memalloc_.alloc_array<double>(
       N * total_vars);
 
   save_varis(varis, y0, args..., t0, t);
 
+  Eigen::Map<Eigen::MatrixXd> jacobian(partials, total_vars, N);
   for (size_t j = 0; j < N; ++j) {
-    // Point to memory allocated in partials to store the derivatives
-    double* partials_j = partials + j * total_vars;
     for (size_t k = 0; k < num_y0_vars; ++k) {
-      partials_j[k] = coupled_state[N + num_y0_vars * k + j];
+      jacobian.coeffRef(k, j) = coupled_state[N + num_y0_vars * k + j];
     }
 
     for (size_t k = 0; k < num_args_vars; ++k) {
-      partials_j[num_y0_vars + k]
+      jacobian.coeffRef(num_y0_vars + k, j)
           = coupled_state[N + N * num_y0_vars + N * k + j];
     }
 
@@ -84,14 +84,15 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
       for (size_t k = 0; k < num_y0_vars; ++k) {
         dyt_dt0 -= f_y0_t0.coeffRef(k) * coupled_state[N + num_y0_vars * k + j];
       }
-      partials_j[num_y0_vars + num_args_vars] = dyt_dt0;
+      jacobian.coeffRef(num_y0_vars + num_args_vars, j) = dyt_dt0;
     }
 
     if (is_var<T_t>::value) {
-      partials_j[num_y0_vars + num_args_vars + num_t0_vars] = f_y_t.coeffRef(j);
+      jacobian.coeffRef(num_y0_vars + num_args_vars + num_t0_vars, j) = f_y_t.coeffRef(j);
     }
 
-    yt(j) = new precomputed_gradients_vari(y(j), total_vars, varis, partials_j);
+    // jacobian_mem + j * total_vars points to the jth column of jacobian
+    yt(j) = new precomputed_gradients_vari(y(j), total_vars, varis, jacobian_mem + j * total_vars);
   }
 
   return yt;

From 509f7b25813ac32ef6c06ba4de39fd8fac5ab3fd Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Thu, 9 Jul 2020 19:11:50 +0000
Subject: [PATCH 177/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

---
 stan/math/rev/functor/ode_store_sensitivities.hpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 753f523c93b..f70b66954f6 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -63,8 +63,9 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
   vari** varis
       = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
   // partials is a column major Jacobian
-  double* jacobian_mem = ChainableStack::instance_->memalloc_.alloc_array<double>(
-      N * total_vars);
+  double* jacobian_mem
+      = ChainableStack::instance_->memalloc_.alloc_array<double>(N
+                                                                 * total_vars);
 
   save_varis(varis, y0, args..., t0, t);
 
@@ -88,11 +89,13 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
     }
 
     if (is_var<T_t>::value) {
-      jacobian.coeffRef(num_y0_vars + num_args_vars + num_t0_vars, j) = f_y_t.coeffRef(j);
+      jacobian.coeffRef(num_y0_vars + num_args_vars + num_t0_vars, j)
+          = f_y_t.coeffRef(j);
     }
 
     // jacobian_mem + j * total_vars points to the jth column of jacobian
-    yt(j) = new precomputed_gradients_vari(y(j), total_vars, varis, jacobian_mem + j * total_vars);
+    yt(j) = new precomputed_gradients_vari(y(j), total_vars, varis,
+                                           jacobian_mem + j * total_vars);
   }
 
   return yt;

From 10acf662087d4454283ffe181611e8db564278cc Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Thu, 9 Jul 2020 15:47:01 -0400
Subject: [PATCH 178/189] Fixed wrong pointer name (design-doc #19)

---
 stan/math/rev/functor/ode_store_sensitivities.hpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 753f523c93b..811e4aac130 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -62,13 +62,15 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
 
   vari** varis
       = ChainableStack::instance_->memalloc_.alloc_array<vari*>(total_vars);
-  // partials is a column major Jacobian
+
+  save_varis(varis, y0, args..., t0, t);
+
+  // memory for a column major jacobian
   double* jacobian_mem = ChainableStack::instance_->memalloc_.alloc_array<double>(
       N * total_vars);
 
-  save_varis(varis, y0, args..., t0, t);
+  Eigen::Map<Eigen::MatrixXd> jacobian(jacobian_mem, total_vars, N);
 
-  Eigen::Map<Eigen::MatrixXd> jacobian(partials, total_vars, N);
   for (size_t j = 0; j < N; ++j) {
     for (size_t k = 0; k < num_y0_vars; ++k) {
       jacobian.coeffRef(k, j) = coupled_state[N + num_y0_vars * k + j];

From 0ce6e188f0f7ba77915af0602c1707180349bcd9 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Thu, 9 Jul 2020 19:52:05 +0000
Subject: [PATCH 179/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

---
 stan/math/rev/functor/ode_store_sensitivities.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 06ccc6afd08..37968466ff7 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -66,8 +66,9 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
   save_varis(varis, y0, args..., t0, t);
 
   // memory for a column major jacobian
-  double* jacobian_mem = ChainableStack::instance_->memalloc_.alloc_array<double>(
-      N * total_vars);
+  double* jacobian_mem
+      = ChainableStack::instance_->memalloc_.alloc_array<double>(N
+                                                                 * total_vars);
 
   Eigen::Map<Eigen::MatrixXd> jacobian(jacobian_mem, total_vars, N);
 

From a5ee85de8f43b1fb2939f6ba34c2dc9a681baab9 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Thu, 9 Jul 2020 18:54:04 -0400
Subject: [PATCH 180/189] Added eval function to call `.eval()` on expressions
 buried in parameter packs (design-doc #19)

---
 stan/math/prim/fun.hpp                        |   1 +
 stan/math/prim/fun/eval.hpp                   |  39 ++++
 stan/math/rev/functor/cvodes_integrator.hpp   |   2 +-
 .../rev/functor/ode_store_sensitivities.hpp   |   4 +-
 test/unit/math/prim/fun/eval_test.cpp         | 202 ++++++++++++++++++
 .../functor/ode_store_sensitivities_test.cpp  |  63 ++++++
 6 files changed, 308 insertions(+), 3 deletions(-)
 create mode 100644 stan/math/prim/fun/eval.hpp
 create mode 100644 test/unit/math/prim/fun/eval_test.cpp

diff --git a/stan/math/prim/fun.hpp b/stan/math/prim/fun.hpp
index 0995013b262..1dcdde8ed05 100644
--- a/stan/math/prim/fun.hpp
+++ b/stan/math/prim/fun.hpp
@@ -82,6 +82,7 @@
 #include <stan/math/prim/fun/elt_multiply.hpp>
 #include <stan/math/prim/fun/erf.hpp>
 #include <stan/math/prim/fun/erfc.hpp>
+#include <stan/math/prim/fun/eval.hpp>
 #include <stan/math/prim/fun/exp.hpp>
 #include <stan/math/prim/fun/exp2.hpp>
 #include <stan/math/prim/fun/expm1.hpp>
diff --git a/stan/math/prim/fun/eval.hpp b/stan/math/prim/fun/eval.hpp
new file mode 100644
index 00000000000..b48e432880d
--- /dev/null
+++ b/stan/math/prim/fun/eval.hpp
@@ -0,0 +1,39 @@
+#ifndef STAN_MATH_PRIM_FUN_EVAL_HPP
+#define STAN_MATH_PRIM_FUN_EVAL_HPP
+
+#include <stan/math/prim/meta.hpp>
+#include <stan/math/prim/fun/Eigen.hpp>
+
+namespace stan {
+namespace math {
+
+/**
+ * Inputs that are not Eigen types are forwarded unmodified
+ *
+ * @tparam T Input type
+ * @param[in] arg Input argument
+ * @return Forwarded input argument
+ **/
+template <typename T,
+	  require_not_eigen_t<T>* = nullptr>
+inline decltype(auto) eval(T&& arg) {
+  return std::forward<T>(arg);
+}
+
+/**
+ * Inputs that are Eigen types are eval'd and returned
+ *
+ * @tparam T Input type
+ * @param[in] arg Input argument
+ * @return Forwarded input argument
+ **/
+template <typename T,
+	  require_eigen_t<T>* = nullptr>
+inline decltype(auto) eval(T&& arg) {
+  return arg.eval();
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif
diff --git a/stan/math/rev/functor/cvodes_integrator.hpp b/stan/math/rev/functor/cvodes_integrator.hpp
index 95375400aa5..70b33f21740 100644
--- a/stan/math/rev/functor/cvodes_integrator.hpp
+++ b/stan/math/rev/functor/cvodes_integrator.hpp
@@ -40,7 +40,7 @@ class cvodes_integrator {
   const T_t0 t0_;
   const std::vector<T_ts>& ts_;
   std::tuple<const T_Args&...> args_tuple_;
-  std::tuple<plain_type_t<decltype(value_of(std::declval<T_Args>()))>...>
+  std::tuple<plain_type_t<decltype(value_of(std::declval<const T_Args&>()))>...>
       value_of_args_tuple_;
   const size_t N_;
   std::ostream* msgs_;
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index 37968466ff7..a56f1c34e1b 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -51,11 +51,11 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
 
   Eigen::VectorXd f_y_t;
   if (is_var<T_t>::value)
-    f_y_t = f(value_of(t), y, msgs, value_of(args)...);
+    f_y_t = f(value_of(t), y, msgs, eval(value_of(args))...);
 
   Eigen::VectorXd f_y0_t0;
   if (is_var<T_t0>::value)
-    f_y0_t0 = f(value_of(t0), value_of(y0).eval(), msgs, value_of(args)...);
+    f_y0_t0 = f(value_of(t0), eval(value_of(y0)), msgs, eval(value_of(args))...);
 
   const size_t total_vars
       = num_y0_vars + num_args_vars + num_t0_vars + num_t_vars;
diff --git a/test/unit/math/prim/fun/eval_test.cpp b/test/unit/math/prim/fun/eval_test.cpp
new file mode 100644
index 00000000000..37bdd6ac312
--- /dev/null
+++ b/test/unit/math/prim/fun/eval_test.cpp
@@ -0,0 +1,202 @@
+#include <stan/math/prim.hpp>
+#include <test/unit/util.hpp>
+#include <gtest/gtest.h>
+#include <cmath>
+#include <limits>
+#include <type_traits>
+#include <vector>
+
+TEST(MathFunctions, eval) {
+  using stan::math::eval;
+  double x = 5.0;
+  EXPECT_FLOAT_EQ(5.0, eval(x));
+  EXPECT_FLOAT_EQ(5.0, eval(5));
+}
+
+TEST(MathMatrixPrimArr, eval) {
+  using stan::math::eval;
+  using std::vector;
+
+  vector<double> a;
+  for (size_t i = 0; i < 10; ++i)
+    a.push_back(i + 1);
+
+  vector<double> b;
+  for (size_t i = 10; i < 15; ++i)
+    b.push_back(i + 1);
+
+  EXPECT_STD_VECTOR_FLOAT_EQ(a, eval(a));
+  EXPECT_STD_VECTOR_FLOAT_EQ(b, eval(b));
+}
+
+TEST(MathFunctions, eval_int_return_type_short_circuit) {
+  std::vector<int> a(5, 0);
+  const std::vector<int> b(5, 0);
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(a)),
+                            std::vector<int>&>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(b)),
+                            const std::vector<int>&>::value));
+}
+
+TEST(MathFunctions, eval_double_return_type_short_circuit) {
+  std::vector<double> a(5, 0);
+  const std::vector<double> b(5, 0);
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(a)),
+                            std::vector<double>&>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(b)),
+                            const std::vector<double>&>::value));
+}
+
+TEST(MathMatrixPrimMat, eval) {
+  using stan::math::eval;
+
+  Eigen::Matrix<double, 2, 5> a;
+  for (int i = 0; i < 2; i++)
+    for (int j = 0; j < 5; j++)
+      a(i, j) = i * 5 + j;
+  Eigen::Matrix<double, 5, 1> b;
+  for (int i = 0; i < 5; i++)
+    for (int j = 0; j < 1; j++)
+      b(i, j) = 10 + i * 5 + j;
+
+  EXPECT_MATRIX_FLOAT_EQ(a, eval(a));
+  EXPECT_MATRIX_FLOAT_EQ(b, eval(b));
+}
+
+TEST(MathFunctions, eval_vector_of_vectors) {
+  std::vector<double> a(5, 0);
+  const std::vector<double> b(5, 0);
+  std::vector<std::vector<double>> va(5, a);
+  const std::vector<std::vector<double>> vb(5, b);
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(va)),
+                            std::vector<std::vector<double>>&>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(vb)),
+                            const std::vector<std::vector<double>>&>::value));
+
+  auto vva = stan::math::eval(va);
+  auto vvb = stan::math::eval(va);
+
+  for (size_t i = 0; i < va.size(); ++i) {
+    for (size_t j = 0; j < va[i].size(); ++j) {
+      EXPECT_FLOAT_EQ(vva[i][j], a[j]);
+    }
+  }
+
+  for (size_t i = 0; i < vb.size(); ++i) {
+    for (size_t j = 0; j < vb[i].size(); ++j) {
+      EXPECT_FLOAT_EQ(vvb[i][j], b[j]);
+    }
+  }
+}
+
+TEST(MathFunctions, eval_vector_of_eigen) {
+  Eigen::VectorXd a = Eigen::VectorXd::Random(5);
+  Eigen::RowVectorXd b = Eigen::RowVectorXd::Random(5);
+  Eigen::MatrixXd c = Eigen::MatrixXd::Random(5, 5);
+  std::vector<Eigen::VectorXd> va(5, a);
+  std::vector<Eigen::RowVectorXd> vb(5, b);
+  std::vector<Eigen::MatrixXd> vc(5, c);
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(va)),
+                            std::vector<Eigen::VectorXd>&>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(vb)),
+                            std::vector<Eigen::RowVectorXd>&>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(vc)),
+                            std::vector<Eigen::MatrixXd>&>::value));
+
+  auto vva = stan::math::eval(va);
+  auto vvb = stan::math::eval(vb);
+  auto vvc = stan::math::eval(vc);
+
+  for (size_t i = 0; i < vva.size(); ++i)
+    EXPECT_MATRIX_FLOAT_EQ(vva[i], a);
+
+  for (size_t i = 0; i < vvb.size(); ++i)
+    EXPECT_MATRIX_FLOAT_EQ(vvb[i], b);
+
+  for (size_t i = 0; i < vvc.size(); ++i)
+    EXPECT_MATRIX_FLOAT_EQ(vvc[i], c);
+}
+
+TEST(MathMatrixPrimMat, eval_expression) {
+  using stan::math::eval;
+
+  Eigen::MatrixXd a = Eigen::MatrixXd::Random(5, 4);
+  Eigen::MatrixXd res_a = eval(2 * a);
+  Eigen::MatrixXd correct_a = 2 * a;
+  EXPECT_MATRIX_EQ(correct_a, res_a);
+
+  Eigen::VectorXi b = Eigen::VectorXi::Random(7);
+  Eigen::VectorXi res_b = eval(2 * b);
+  Eigen::VectorXi correct_b = 2 * b;
+  EXPECT_TYPED_MATRIX_EQ(correct_b, res_b, int);
+
+  Eigen::ArrayXXd c = a.array();
+  Eigen::ArrayXXd res_c = eval(2 * c);
+  Eigen::ArrayXXd correct_c = 2 * c;
+  for (int i = 0; i < res_c.size(); i++)
+    EXPECT_EQ(correct_c(i), res_c(i));
+}
+
+TEST(MathFunctions, eval_return_type_short_circuit_std_vector) {
+  std::vector<double> a(5);
+  const std::vector<double> b(5);
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(a)),
+                            std::vector<double>&>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(b)),
+                            const std::vector<double>&>::value));
+}
+
+TEST(MathFunctions, eval_return_type_short_circuit_vector_xd) {
+  Eigen::Matrix<double, Eigen::Dynamic, 1> a(5);
+  const Eigen::Matrix<double, Eigen::Dynamic, 1> b(5);
+  stan::math::eval(a);
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(a)),
+	       const Eigen::Matrix<double, Eigen::Dynamic, 1>&>::value));
+  EXPECT_TRUE(
+      (std::is_same<decltype(stan::math::eval(b)),
+                    const Eigen::Matrix<double, Eigen::Dynamic, 1>&>::value));
+}
+
+TEST(MathFunctions, eval_return_type_short_circuit_row_vector_xd) {
+  Eigen::Matrix<double, 1, Eigen::Dynamic> a(5);
+  const Eigen::Matrix<double, 1, Eigen::Dynamic> b(5);
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(a)),
+	       const Eigen::Matrix<double, 1, Eigen::Dynamic>&>::value));
+  EXPECT_TRUE(
+      (std::is_same<decltype(stan::math::eval(b)),
+                    const Eigen::Matrix<double, 1, Eigen::Dynamic>&>::value));
+}
+
+TEST(MathFunctions, eval_return_type_short_circuit_matrix_xd) {
+  Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> a(5, 4);
+  const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> b(5, 4);
+  EXPECT_TRUE((std::is_same<
+               decltype(stan::math::eval(a)),
+               const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>&>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(b)),
+                            const Eigen::Matrix<double, Eigen::Dynamic,
+                                                Eigen::Dynamic>&>::value));
+}
+
+TEST(MathFunctions, eval_return_type_expression) {
+  const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> a(5, 4);
+  Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> b(4, 4);
+
+  const auto& expr_a = 3 * a;
+  auto expr_b = b * b;
+
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(expr_a)),
+	       const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(expr_b)),
+	       const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>>::value));
+}
+
+TEST(MathFunctions, eval_return_type_short_circuit_static_sized_matrix) {
+  Eigen::Matrix<double, 5, 4> a;
+  const Eigen::Matrix<double, 5, 4> b;
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(a)),
+	       const Eigen::Matrix<double, 5, 4>&>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(b)),
+	       const Eigen::Matrix<double, 5, 4>&>::value));
+}
+
diff --git a/test/unit/math/rev/functor/ode_store_sensitivities_test.cpp b/test/unit/math/rev/functor/ode_store_sensitivities_test.cpp
index c76546b438f..f0bfdc88691 100644
--- a/test/unit/math/rev/functor/ode_store_sensitivities_test.cpp
+++ b/test/unit/math/rev/functor/ode_store_sensitivities_test.cpp
@@ -37,6 +37,20 @@ struct ayt {
   }
 };
 
+struct aytm {
+  template <typename T0, typename T_y, typename T_Arg, int R, int C>
+  inline auto operator()(const T0& t, const T_y& y, std::ostream* msgs,
+                         const Eigen::Matrix<T_Arg, R, C>& args) const {
+    std::vector<typename stan::return_type<T_Arg>::type> vec
+        = {sum_(args)};
+    Eigen::Matrix<stan::return_type_t<T0, T_y, T_Arg>, Eigen::Dynamic, 1>
+        out(2);
+    out(0) = -sum_(vec) * y(0) * t;
+    out(1) = -1.7 * sum_(vec) * y(1) * t;
+    return out;
+  }
+};
+
 TEST(AgradRev, ode_store_sensitivities) {
   using stan::math::coupled_ode_system;
   using stan::math::var;
@@ -84,3 +98,52 @@ TEST(AgradRev, ode_store_sensitivities) {
 
   stan::math::recover_memory();
 }
+
+TEST(AgradRev, ode_store_sensitivities_matrix) {
+  using stan::math::coupled_ode_system;
+  using stan::math::var;
+
+  Eigen::VectorXd y0(2);
+  y0 << 0.1, 0.2;
+  Eigen::Matrix<var, Eigen::Dynamic, 1> y0v = y0.template cast<var>();
+
+  double a = 1.3;
+  Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> av(1, 1);
+  av(0, 0) = a;
+
+  aytm func;
+
+  double t0 = 0.5;
+  double t = 0.75;
+
+  var t0v = t0;
+  var tv = t;
+
+  std::vector<double> coupled_state = {-0.0975,  -0.3315,  -3.12000, -5.46975,
+                                       -4.29000, -7.45875, -2.1225,  -3.9015};
+
+  auto output = stan::math::ode_store_sensitivities(func, coupled_state, y0v,
+                                                    t0v, tv, nullptr, av);
+
+  output(0).grad();
+
+  EXPECT_FLOAT_EQ(output(0).val(), -0.0975);
+  EXPECT_FLOAT_EQ(y0v(0).adj(), -3.12);
+  EXPECT_FLOAT_EQ(y0v(1).adj(), -4.29);
+  EXPECT_FLOAT_EQ(av(0, 0).adj(), -2.1225);
+  EXPECT_FLOAT_EQ(t0v.adj(), -1.15089);
+  EXPECT_FLOAT_EQ(tv.adj(), 0.0950625);
+
+  stan::math::set_zero_all_adjoints();
+
+  output(1).grad();
+
+  EXPECT_FLOAT_EQ(output(1).val(), -0.3315);
+  EXPECT_FLOAT_EQ(y0v(0).adj(), -5.46975);
+  EXPECT_FLOAT_EQ(y0v(1).adj(), -7.45875);
+  EXPECT_FLOAT_EQ(av(0, 0).adj(), -3.9015);
+  EXPECT_FLOAT_EQ(t0v.adj(), -2.003918);
+  EXPECT_FLOAT_EQ(tv.adj(), 0.5494613);
+
+  stan::math::recover_memory();
+}

From 49bfc458183e453151d65f24e9f00ab3fe472a17 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Thu, 9 Jul 2020 22:56:41 +0000
Subject: [PATCH 181/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2~16.04.1 (tags/RELEASE_600/final)

---
 stan/math/prim/fun/eval.hpp                   |  6 +--
 .../rev/functor/ode_store_sensitivities.hpp   |  3 +-
 test/unit/math/prim/fun/eval_test.cpp         | 37 +++++++++++--------
 .../functor/ode_store_sensitivities_test.cpp  |  7 ++--
 4 files changed, 28 insertions(+), 25 deletions(-)

diff --git a/stan/math/prim/fun/eval.hpp b/stan/math/prim/fun/eval.hpp
index b48e432880d..4a9a17a1cd9 100644
--- a/stan/math/prim/fun/eval.hpp
+++ b/stan/math/prim/fun/eval.hpp
@@ -14,8 +14,7 @@ namespace math {
  * @param[in] arg Input argument
  * @return Forwarded input argument
  **/
-template <typename T,
-	  require_not_eigen_t<T>* = nullptr>
+template <typename T, require_not_eigen_t<T>* = nullptr>
 inline decltype(auto) eval(T&& arg) {
   return std::forward<T>(arg);
 }
@@ -27,8 +26,7 @@ inline decltype(auto) eval(T&& arg) {
  * @param[in] arg Input argument
  * @return Forwarded input argument
  **/
-template <typename T,
-	  require_eigen_t<T>* = nullptr>
+template <typename T, require_eigen_t<T>* = nullptr>
 inline decltype(auto) eval(T&& arg) {
   return arg.eval();
 }
diff --git a/stan/math/rev/functor/ode_store_sensitivities.hpp b/stan/math/rev/functor/ode_store_sensitivities.hpp
index a56f1c34e1b..8a93ff846df 100644
--- a/stan/math/rev/functor/ode_store_sensitivities.hpp
+++ b/stan/math/rev/functor/ode_store_sensitivities.hpp
@@ -55,7 +55,8 @@ Eigen::Matrix<var, Eigen::Dynamic, 1> ode_store_sensitivities(
 
   Eigen::VectorXd f_y0_t0;
   if (is_var<T_t0>::value)
-    f_y0_t0 = f(value_of(t0), eval(value_of(y0)), msgs, eval(value_of(args))...);
+    f_y0_t0
+        = f(value_of(t0), eval(value_of(y0)), msgs, eval(value_of(args))...);
 
   const size_t total_vars
       = num_y0_vars + num_args_vars + num_t0_vars + num_t_vars;
diff --git a/test/unit/math/prim/fun/eval_test.cpp b/test/unit/math/prim/fun/eval_test.cpp
index 37bdd6ac312..b9c2bedb541 100644
--- a/test/unit/math/prim/fun/eval_test.cpp
+++ b/test/unit/math/prim/fun/eval_test.cpp
@@ -32,8 +32,8 @@ TEST(MathMatrixPrimArr, eval) {
 TEST(MathFunctions, eval_int_return_type_short_circuit) {
   std::vector<int> a(5, 0);
   const std::vector<int> b(5, 0);
-  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(a)),
-                            std::vector<int>&>::value));
+  EXPECT_TRUE(
+      (std::is_same<decltype(stan::math::eval(a)), std::vector<int>&>::value));
   EXPECT_TRUE((std::is_same<decltype(stan::math::eval(b)),
                             const std::vector<int>&>::value));
 }
@@ -150,8 +150,9 @@ TEST(MathFunctions, eval_return_type_short_circuit_vector_xd) {
   Eigen::Matrix<double, Eigen::Dynamic, 1> a(5);
   const Eigen::Matrix<double, Eigen::Dynamic, 1> b(5);
   stan::math::eval(a);
-  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(a)),
-	       const Eigen::Matrix<double, Eigen::Dynamic, 1>&>::value));
+  EXPECT_TRUE(
+      (std::is_same<decltype(stan::math::eval(a)),
+                    const Eigen::Matrix<double, Eigen::Dynamic, 1>&>::value));
   EXPECT_TRUE(
       (std::is_same<decltype(stan::math::eval(b)),
                     const Eigen::Matrix<double, Eigen::Dynamic, 1>&>::value));
@@ -160,8 +161,9 @@ TEST(MathFunctions, eval_return_type_short_circuit_vector_xd) {
 TEST(MathFunctions, eval_return_type_short_circuit_row_vector_xd) {
   Eigen::Matrix<double, 1, Eigen::Dynamic> a(5);
   const Eigen::Matrix<double, 1, Eigen::Dynamic> b(5);
-  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(a)),
-	       const Eigen::Matrix<double, 1, Eigen::Dynamic>&>::value));
+  EXPECT_TRUE(
+      (std::is_same<decltype(stan::math::eval(a)),
+                    const Eigen::Matrix<double, 1, Eigen::Dynamic>&>::value));
   EXPECT_TRUE(
       (std::is_same<decltype(stan::math::eval(b)),
                     const Eigen::Matrix<double, 1, Eigen::Dynamic>&>::value));
@@ -170,9 +172,9 @@ TEST(MathFunctions, eval_return_type_short_circuit_row_vector_xd) {
 TEST(MathFunctions, eval_return_type_short_circuit_matrix_xd) {
   Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> a(5, 4);
   const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> b(5, 4);
-  EXPECT_TRUE((std::is_same<
-               decltype(stan::math::eval(a)),
-               const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>&>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(a)),
+                            const Eigen::Matrix<double, Eigen::Dynamic,
+                                                Eigen::Dynamic>&>::value));
   EXPECT_TRUE((std::is_same<decltype(stan::math::eval(b)),
                             const Eigen::Matrix<double, Eigen::Dynamic,
                                                 Eigen::Dynamic>&>::value));
@@ -185,18 +187,21 @@ TEST(MathFunctions, eval_return_type_expression) {
   const auto& expr_a = 3 * a;
   auto expr_b = b * b;
 
-  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(expr_a)),
-	       const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>>::value));
-  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(expr_b)),
-	       const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>>::value));
+  EXPECT_TRUE(
+      (std::is_same<
+          decltype(stan::math::eval(expr_a)),
+          const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>>::value));
+  EXPECT_TRUE(
+      (std::is_same<
+          decltype(stan::math::eval(expr_b)),
+          const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>>::value));
 }
 
 TEST(MathFunctions, eval_return_type_short_circuit_static_sized_matrix) {
   Eigen::Matrix<double, 5, 4> a;
   const Eigen::Matrix<double, 5, 4> b;
   EXPECT_TRUE((std::is_same<decltype(stan::math::eval(a)),
-	       const Eigen::Matrix<double, 5, 4>&>::value));
+                            const Eigen::Matrix<double, 5, 4>&>::value));
   EXPECT_TRUE((std::is_same<decltype(stan::math::eval(b)),
-	       const Eigen::Matrix<double, 5, 4>&>::value));
+                            const Eigen::Matrix<double, 5, 4>&>::value));
 }
-
diff --git a/test/unit/math/rev/functor/ode_store_sensitivities_test.cpp b/test/unit/math/rev/functor/ode_store_sensitivities_test.cpp
index f0bfdc88691..b49028f03e9 100644
--- a/test/unit/math/rev/functor/ode_store_sensitivities_test.cpp
+++ b/test/unit/math/rev/functor/ode_store_sensitivities_test.cpp
@@ -41,10 +41,9 @@ struct aytm {
   template <typename T0, typename T_y, typename T_Arg, int R, int C>
   inline auto operator()(const T0& t, const T_y& y, std::ostream* msgs,
                          const Eigen::Matrix<T_Arg, R, C>& args) const {
-    std::vector<typename stan::return_type<T_Arg>::type> vec
-        = {sum_(args)};
-    Eigen::Matrix<stan::return_type_t<T0, T_y, T_Arg>, Eigen::Dynamic, 1>
-        out(2);
+    std::vector<typename stan::return_type<T_Arg>::type> vec = {sum_(args)};
+    Eigen::Matrix<stan::return_type_t<T0, T_y, T_Arg>, Eigen::Dynamic, 1> out(
+        2);
     out(0) = -sum_(vec) * y(0) * t;
     out(1) = -1.7 * sum_(vec) * y(1) * t;
     return out;

From 2e83467a4cf9c44c8e1ab35ec2b0bd2e67ebed31 Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Thu, 9 Jul 2020 19:50:27 -0400
Subject: [PATCH 182/189] Fixed doxygen problem though I'm not sure how
 (design-doc #19)

---
 stan/math/prim/fun/eval.hpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/stan/math/prim/fun/eval.hpp b/stan/math/prim/fun/eval.hpp
index b48e432880d..1fb4848f370 100644
--- a/stan/math/prim/fun/eval.hpp
+++ b/stan/math/prim/fun/eval.hpp
@@ -3,6 +3,8 @@
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <cstddef>
+#include <vector>
 
 namespace stan {
 namespace math {
@@ -25,11 +27,11 @@ inline decltype(auto) eval(T&& arg) {
  *
  * @tparam T Input type
  * @param[in] arg Input argument
- * @return Forwarded input argument
+ * @return Eval'd argument
  **/
 template <typename T,
 	  require_eigen_t<T>* = nullptr>
-inline decltype(auto) eval(T&& arg) {
+inline decltype(auto) eval(T arg) {
   return arg.eval();
 }
 

From 3b4c217b420fa73db2df8820b62683fc0faa348a Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Fri, 10 Jul 2020 09:34:45 -0400
Subject: [PATCH 183/189] Updated eval implementation and tests (design-docs
 #19)

---
 stan/math/prim/fun/eval.hpp           | 14 +++++++++-----
 test/unit/math/prim/fun/eval_test.cpp |  9 ++++-----
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/stan/math/prim/fun/eval.hpp b/stan/math/prim/fun/eval.hpp
index 9680becea18..8132e661a60 100644
--- a/stan/math/prim/fun/eval.hpp
+++ b/stan/math/prim/fun/eval.hpp
@@ -10,26 +10,30 @@ namespace stan {
 namespace math {
 
 /**
- * Inputs that are not Eigen types are forwarded unmodified
+ * Inputs which have a plain_type equal to the own time are forwarded
+ * unmodified (for Eigen expressions these types are different)
  *
  * @tparam T Input type
  * @param[in] arg Input argument
  * @return Forwarded input argument
  **/
-template <typename T, require_not_eigen_t<T>* = nullptr>
+template <typename T,
+	  require_same_t<std::decay_t<T>, plain_type_t<T>>* = nullptr>
 inline decltype(auto) eval(T&& arg) {
   return std::forward<T>(arg);
 }
 
 /**
- * Inputs that are Eigen types are eval'd and returned
+ * Inputs which have a plain_type different from their own type are
+ * Eval'd (this catches Eigen expressions)
  *
  * @tparam T Input type
  * @param[in] arg Input argument
  * @return Eval'd argument
  **/
-template <typename T, require_eigen_t<T>* = nullptr>
-inline decltype(auto) eval(T arg) {
+template <typename T,
+	  require_not_same_t<std::decay_t<T>, plain_type_t<T>>* = nullptr>
+inline decltype(auto) eval(const T& arg) {
   return arg.eval();
 }
 
diff --git a/test/unit/math/prim/fun/eval_test.cpp b/test/unit/math/prim/fun/eval_test.cpp
index b9c2bedb541..b5dedb3cf6b 100644
--- a/test/unit/math/prim/fun/eval_test.cpp
+++ b/test/unit/math/prim/fun/eval_test.cpp
@@ -149,10 +149,9 @@ TEST(MathFunctions, eval_return_type_short_circuit_std_vector) {
 TEST(MathFunctions, eval_return_type_short_circuit_vector_xd) {
   Eigen::Matrix<double, Eigen::Dynamic, 1> a(5);
   const Eigen::Matrix<double, Eigen::Dynamic, 1> b(5);
-  stan::math::eval(a);
   EXPECT_TRUE(
       (std::is_same<decltype(stan::math::eval(a)),
-                    const Eigen::Matrix<double, Eigen::Dynamic, 1>&>::value));
+                    Eigen::Matrix<double, Eigen::Dynamic, 1>&>::value));
   EXPECT_TRUE(
       (std::is_same<decltype(stan::math::eval(b)),
                     const Eigen::Matrix<double, Eigen::Dynamic, 1>&>::value));
@@ -163,7 +162,7 @@ TEST(MathFunctions, eval_return_type_short_circuit_row_vector_xd) {
   const Eigen::Matrix<double, 1, Eigen::Dynamic> b(5);
   EXPECT_TRUE(
       (std::is_same<decltype(stan::math::eval(a)),
-                    const Eigen::Matrix<double, 1, Eigen::Dynamic>&>::value));
+                    Eigen::Matrix<double, 1, Eigen::Dynamic>&>::value));
   EXPECT_TRUE(
       (std::is_same<decltype(stan::math::eval(b)),
                     const Eigen::Matrix<double, 1, Eigen::Dynamic>&>::value));
@@ -173,7 +172,7 @@ TEST(MathFunctions, eval_return_type_short_circuit_matrix_xd) {
   Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> a(5, 4);
   const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> b(5, 4);
   EXPECT_TRUE((std::is_same<decltype(stan::math::eval(a)),
-                            const Eigen::Matrix<double, Eigen::Dynamic,
+	                    Eigen::Matrix<double, Eigen::Dynamic,
                                                 Eigen::Dynamic>&>::value));
   EXPECT_TRUE((std::is_same<decltype(stan::math::eval(b)),
                             const Eigen::Matrix<double, Eigen::Dynamic,
@@ -201,7 +200,7 @@ TEST(MathFunctions, eval_return_type_short_circuit_static_sized_matrix) {
   Eigen::Matrix<double, 5, 4> a;
   const Eigen::Matrix<double, 5, 4> b;
   EXPECT_TRUE((std::is_same<decltype(stan::math::eval(a)),
-                            const Eigen::Matrix<double, 5, 4>&>::value));
+                            Eigen::Matrix<double, 5, 4>&>::value));
   EXPECT_TRUE((std::is_same<decltype(stan::math::eval(b)),
                             const Eigen::Matrix<double, 5, 4>&>::value));
 }

From a589de9d98dfacead97511088cb4283f5648219c Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Fri, 10 Jul 2020 09:35:45 -0400
Subject: [PATCH 184/189] Removed unnecessary headers (design-doc #19)

---
 stan/math/prim/fun/eval.hpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/stan/math/prim/fun/eval.hpp b/stan/math/prim/fun/eval.hpp
index 8132e661a60..9e55ff5907d 100644
--- a/stan/math/prim/fun/eval.hpp
+++ b/stan/math/prim/fun/eval.hpp
@@ -3,8 +3,6 @@
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <cstddef>
-#include <vector>
 
 namespace stan {
 namespace math {

From a37be47286418cfc031fd7c0bbe2d6f243a710d5 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 10 Jul 2020 09:36:49 -0400
Subject: [PATCH 185/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 stan/math/prim/fun/eval.hpp           |  4 ++--
 test/unit/math/prim/fun/eval_test.cpp | 16 +++++++---------
 2 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/stan/math/prim/fun/eval.hpp b/stan/math/prim/fun/eval.hpp
index 9e55ff5907d..a8d5554b995 100644
--- a/stan/math/prim/fun/eval.hpp
+++ b/stan/math/prim/fun/eval.hpp
@@ -16,7 +16,7 @@ namespace math {
  * @return Forwarded input argument
  **/
 template <typename T,
-	  require_same_t<std::decay_t<T>, plain_type_t<T>>* = nullptr>
+          require_same_t<std::decay_t<T>, plain_type_t<T>>* = nullptr>
 inline decltype(auto) eval(T&& arg) {
   return std::forward<T>(arg);
 }
@@ -30,7 +30,7 @@ inline decltype(auto) eval(T&& arg) {
  * @return Eval'd argument
  **/
 template <typename T,
-	  require_not_same_t<std::decay_t<T>, plain_type_t<T>>* = nullptr>
+          require_not_same_t<std::decay_t<T>, plain_type_t<T>>* = nullptr>
 inline decltype(auto) eval(const T& arg) {
   return arg.eval();
 }
diff --git a/test/unit/math/prim/fun/eval_test.cpp b/test/unit/math/prim/fun/eval_test.cpp
index b5dedb3cf6b..ca40918f056 100644
--- a/test/unit/math/prim/fun/eval_test.cpp
+++ b/test/unit/math/prim/fun/eval_test.cpp
@@ -149,9 +149,8 @@ TEST(MathFunctions, eval_return_type_short_circuit_std_vector) {
 TEST(MathFunctions, eval_return_type_short_circuit_vector_xd) {
   Eigen::Matrix<double, Eigen::Dynamic, 1> a(5);
   const Eigen::Matrix<double, Eigen::Dynamic, 1> b(5);
-  EXPECT_TRUE(
-      (std::is_same<decltype(stan::math::eval(a)),
-                    Eigen::Matrix<double, Eigen::Dynamic, 1>&>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(a)),
+                            Eigen::Matrix<double, Eigen::Dynamic, 1>&>::value));
   EXPECT_TRUE(
       (std::is_same<decltype(stan::math::eval(b)),
                     const Eigen::Matrix<double, Eigen::Dynamic, 1>&>::value));
@@ -160,9 +159,8 @@ TEST(MathFunctions, eval_return_type_short_circuit_vector_xd) {
 TEST(MathFunctions, eval_return_type_short_circuit_row_vector_xd) {
   Eigen::Matrix<double, 1, Eigen::Dynamic> a(5);
   const Eigen::Matrix<double, 1, Eigen::Dynamic> b(5);
-  EXPECT_TRUE(
-      (std::is_same<decltype(stan::math::eval(a)),
-                    Eigen::Matrix<double, 1, Eigen::Dynamic>&>::value));
+  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(a)),
+                            Eigen::Matrix<double, 1, Eigen::Dynamic>&>::value));
   EXPECT_TRUE(
       (std::is_same<decltype(stan::math::eval(b)),
                     const Eigen::Matrix<double, 1, Eigen::Dynamic>&>::value));
@@ -171,9 +169,9 @@ TEST(MathFunctions, eval_return_type_short_circuit_row_vector_xd) {
 TEST(MathFunctions, eval_return_type_short_circuit_matrix_xd) {
   Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> a(5, 4);
   const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> b(5, 4);
-  EXPECT_TRUE((std::is_same<decltype(stan::math::eval(a)),
-	                    Eigen::Matrix<double, Eigen::Dynamic,
-                                                Eigen::Dynamic>&>::value));
+  EXPECT_TRUE((std::is_same<
+               decltype(stan::math::eval(a)),
+               Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>&>::value));
   EXPECT_TRUE((std::is_same<decltype(stan::math::eval(b)),
                             const Eigen::Matrix<double, Eigen::Dynamic,
                                                 Eigen::Dynamic>&>::value));

From 43fb63b10019ef137bd7c8fb3650a6306668f46f Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Fri, 10 Jul 2020 17:00:03 -0400
Subject: [PATCH 186/189] Switched integrate_ode_bdf, integrate_ode_adams, and
 integrate_ode_rk45 to use functors compatible with previous release

---
 ...grate_ode_std_vector_interface_adapter.hpp |  2 +-
 .../functor/forced_harmonic_oscillator.hpp    |  4 +--
 .../math/prim/functor/harmonic_oscillator.hpp | 16 ++++++------
 ..._ode_std_vector_interface_adapter_test.cpp |  2 +-
 test/unit/math/prim/functor/lorenz.hpp        |  4 +--
 test/unit/math/rev/functor/coupled_mm.hpp     |  4 +--
 .../math/rev/functor/cvodes_utils_test.cpp    | 26 +++++++++++++++++++
 .../functor/integrate_ode_adams_rev_test.cpp  |  2 +-
 .../functor/integrate_ode_bdf_rev_test.cpp    |  2 +-
 .../integrate_ode_cvodes_grad_rev_test.cpp    |  4 +--
 .../functor/integrate_ode_rk45_grad_test.cpp  |  4 +--
 .../functor/integrate_ode_rk45_rev_test.cpp   |  2 +-
 ..._ode_std_vector_interface_adapter_test.cpp |  6 ++---
 13 files changed, 52 insertions(+), 26 deletions(-)
 create mode 100644 test/unit/math/rev/functor/cvodes_utils_test.cpp

diff --git a/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp b/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp
index 36b65e4402f..9b0178e27b5 100644
--- a/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp
+++ b/stan/math/prim/functor/integrate_ode_std_vector_interface_adapter.hpp
@@ -30,7 +30,7 @@ struct integrate_ode_std_vector_interface_adapter {
                   std::ostream* msgs, const std::vector<T2>& theta,
                   const std::vector<double>& x,
                   const std::vector<int>& x_int) const {
-    return to_vector(f_(t, to_array_1d(y), msgs, theta, x, x_int));
+    return to_vector(f_(t, to_array_1d(y), theta, x, x_int, msgs));
   }
 };
 
diff --git a/test/unit/math/prim/functor/forced_harmonic_oscillator.hpp b/test/unit/math/prim/functor/forced_harmonic_oscillator.hpp
index 8f119750b9e..5161e021683 100644
--- a/test/unit/math/prim/functor/forced_harmonic_oscillator.hpp
+++ b/test/unit/math/prim/functor/forced_harmonic_oscillator.hpp
@@ -13,9 +13,9 @@ struct forced_harm_osc_ode_fun {
   // parameters
   // double data
   // integer data
-  operator()(const T0& t_in, const std::vector<T1>& y_in, std::ostream* msgs,
+  operator()(const T0& t_in, const std::vector<T1>& y_in,
              const std::vector<T2>& theta, const std::vector<double>& x,
-             const std::vector<int>& x_int) const {
+             const std::vector<int>& x_int, std::ostream* msgs) const {
     if (y_in.size() != 2)
       throw std::domain_error(
           "this function was called with inconsistent state");
diff --git a/test/unit/math/prim/functor/harmonic_oscillator.hpp b/test/unit/math/prim/functor/harmonic_oscillator.hpp
index 21dfa3d089d..6c409e36496 100644
--- a/test/unit/math/prim/functor/harmonic_oscillator.hpp
+++ b/test/unit/math/prim/functor/harmonic_oscillator.hpp
@@ -13,9 +13,9 @@ struct harm_osc_ode_fun {
   // parameters
   // double data
   // integer data
-  operator()(const T0& t_in, const std::vector<T1>& y_in, std::ostream* msgs,
+  operator()(const T0& t_in, const std::vector<T1>& y_in,
              const std::vector<T2>& theta, const std::vector<double>& x,
-             const std::vector<int>& x_int) const {
+             const std::vector<int>& x_int, std::ostream* msgs) const {
     if (y_in.size() != 2)
       throw std::domain_error(
           "this function was called with inconsistent state");
@@ -55,9 +55,9 @@ struct harm_osc_ode_data_fun {
   // parameters
   // double data
   // integer data
-  operator()(const T0& t_in, const std::vector<T1>& y_in, std::ostream* msgs,
+  operator()(const T0& t_in, const std::vector<T1>& y_in,
              const std::vector<T2>& theta, const std::vector<double>& x,
-             const std::vector<int>& x_int) const {
+             const std::vector<int>& x_int, std::ostream* msgs) const {
     if (y_in.size() != 2)
       throw std::domain_error(
           "this function was called with inconsistent state");
@@ -79,9 +79,9 @@ struct harm_osc_ode_wrong_size_1_fun {
   // parameters
   // double data
   // integer data
-  operator()(const T0& t_in, const std::vector<T1>& y_in, std::ostream* msgs,
+  operator()(const T0& t_in, const std::vector<T1>& y_in,
              const std::vector<T2>& theta, const std::vector<double>& x,
-             const std::vector<int>& x_int) const {
+             const std::vector<int>& x_int, std::ostream* msgs) const {
     if (y_in.size() != 2)
       throw std::domain_error(
           "this function was called with inconsistent state");
@@ -103,9 +103,9 @@ struct harm_osc_ode_wrong_size_2_fun {
   // parameters
   // double data
   // integer data
-  operator()(const T0& t_in, const std::vector<T1>& y_in, std::ostream* msgs,
+  operator()(const T0& t_in, const std::vector<T1>& y_in,
              const std::vector<T2>& theta, const std::vector<double>& x,
-             const std::vector<int>& x_int) const {
+             const std::vector<int>& x_int, std::ostream* msgs) const {
     if (y_in.size() != 2)
       throw std::domain_error(
           "this function was called with inconsistent state");
diff --git a/test/unit/math/prim/functor/integrate_ode_std_vector_interface_adapter_test.cpp b/test/unit/math/prim/functor/integrate_ode_std_vector_interface_adapter_test.cpp
index 8009cbdbb65..1d7f484a356 100644
--- a/test/unit/math/prim/functor/integrate_ode_std_vector_interface_adapter_test.cpp
+++ b/test/unit/math/prim/functor/integrate_ode_std_vector_interface_adapter_test.cpp
@@ -19,7 +19,7 @@ TEST(StanMath, check_values) {
   double t = 1.0;
 
   Eigen::VectorXd out1
-      = stan::math::to_vector(harm_osc(t, y, nullptr, theta, x, x_int));
+      = stan::math::to_vector(harm_osc(t, y, theta, x, x_int, nullptr));
   Eigen::VectorXd out2
       = harm_osc_adapted(t, stan::math::to_vector(y), nullptr, theta, x, x_int);
 
diff --git a/test/unit/math/prim/functor/lorenz.hpp b/test/unit/math/prim/functor/lorenz.hpp
index 5914f39de72..b523a890529 100644
--- a/test/unit/math/prim/functor/lorenz.hpp
+++ b/test/unit/math/prim/functor/lorenz.hpp
@@ -29,9 +29,9 @@ struct lorenz_ode_fun {
   // parameters
   // double data
   // integer data
-  operator()(const T0& t_in, const std::vector<T1>& y_in, std::ostream* msgs,
+  operator()(const T0& t_in, const std::vector<T1>& y_in,
              const std::vector<T2>& theta, const std::vector<double>& x,
-             const std::vector<int>& x_int) const {
+             const std::vector<int>& x_int, std::ostream* msgs) const {
     return lorenz_ode(t_in, y_in, theta, x, x_int);
   }
 };
diff --git a/test/unit/math/rev/functor/coupled_mm.hpp b/test/unit/math/rev/functor/coupled_mm.hpp
index a1864f130ed..49d13a268b7 100644
--- a/test/unit/math/rev/functor/coupled_mm.hpp
+++ b/test/unit/math/rev/functor/coupled_mm.hpp
@@ -12,9 +12,9 @@ struct coupled_mm_ode_fun {
   // parameters
   // double data
   // integer data
-  operator()(const T0& t_in, const std::vector<T1>& y, std::ostream* msgs,
+  operator()(const T0& t_in, const std::vector<T1>& y,
              const std::vector<T2>& parms, const std::vector<double>& sx,
-             const std::vector<int>& sx_int) const {
+             const std::vector<int>& sx_int, std::ostream* msgs) const {
     std::vector<stan::return_type_t<T1, T2>> ydot(2);
 
     const T2 act = parms[0];
diff --git a/test/unit/math/rev/functor/cvodes_utils_test.cpp b/test/unit/math/rev/functor/cvodes_utils_test.cpp
new file mode 100644
index 00000000000..b39e13d85f6
--- /dev/null
+++ b/test/unit/math/rev/functor/cvodes_utils_test.cpp
@@ -0,0 +1,26 @@
+#include <stan/math/rev.hpp>
+#include <gtest/gtest.h>
+#include <test/unit/util.hpp>
+#include <iostream>
+#include <vector>
+
+struct Inverse {
+  template <typename T0, typename T_y>
+  inline Eigen::Matrix<stan::return_type_t<T_y>, Eigen::Dynamic, 1>
+  operator()(const T0& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y, std::ostream* msgs) const {
+    Eigen::Matrix<T_y, Eigen::Dynamic, 1> out(1);
+    out(0) = 1.0 / (y(0) - 1.0);
+    return out;
+  }
+};
+
+TEST(StanMath, cvodes_error_handler) {
+  Eigen::VectorXd y0 = Eigen::VectorXd::Ones(1);
+  int t0 = 0;
+  std::vector<double> ts = {0.45, 1.1};
+
+  std::string msg = "CVODES: CVode Internal t = 0 and h = 0 are such that t + h = t on the next step";
+  
+  EXPECT_THROW_MSG(stan::math::ode_bdf(Inverse(), y0, t0, ts, nullptr),
+    		   std::domain_error, msg);
+}
diff --git a/test/unit/math/rev/functor/integrate_ode_adams_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_adams_rev_test.cpp
index 0c89dfcf26d..ef6a9ae0fa7 100644
--- a/test/unit/math/rev/functor/integrate_ode_adams_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_adams_rev_test.cpp
@@ -215,7 +215,7 @@ TEST(StanAgradRevOde_integrate_ode_adams, time_steps_as_param_AD) {
           } else {
             std::vector<double> y0(res_d.begin(), res_d.begin() + ns);
             EXPECT_FLOAT_EQ(g[k],
-                            ode(ts[i].val(), y0, msgs, theta, x, x_int)[j]);
+                            ode(ts[i].val(), y0, theta, x, x_int, msgs)[j]);
           }
         }
         stan::math::set_zero_all_adjoints();
diff --git a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
index 123cfce37f6..12bc82eb515 100644
--- a/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_bdf_rev_test.cpp
@@ -245,7 +245,7 @@ TEST(StanAgradRevOde_integrate_ode_bdf, time_steps_as_param_AD) {
           } else {
             std::vector<double> y0(res_d.begin(), res_d.begin() + ns);
             EXPECT_FLOAT_EQ(ts[k].adj(),
-                            ode(ts[i].val(), y0, msgs, theta, x, x_int)[j]);
+                            ode(ts[i].val(), y0, theta, x, x_int, msgs)[j]);
           }
         }
         stan::math::set_zero_all_adjoints();
diff --git a/test/unit/math/rev/functor/integrate_ode_cvodes_grad_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_cvodes_grad_rev_test.cpp
index c94a6503082..22dd71bfd86 100644
--- a/test/unit/math/rev/functor/integrate_ode_cvodes_grad_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_cvodes_grad_rev_test.cpp
@@ -38,10 +38,10 @@ class sho_functor {
   inline std::vector<stan::return_type_t<T1, T2>> operator()(
       const T0& t_in,                         // time
       const std::vector<T1>& y_in,            // state
-      std::ostream* msgs,                     // error stream
       const std::vector<T2>& theta,           // parameters
       const std::vector<double>& x,           // double data
-      const std::vector<int>& x_int) const {  // integer data
+      const std::vector<int>& x_int,          // integer data
+      std::ostream* msgs) const {             // error stream
     if (y_in.size() != 2)
       throw std::domain_error("Functor called with inconsistent state");
 
diff --git a/test/unit/math/rev/functor/integrate_ode_rk45_grad_test.cpp b/test/unit/math/rev/functor/integrate_ode_rk45_grad_test.cpp
index fafae56b3df..942b62b3668 100644
--- a/test/unit/math/rev/functor/integrate_ode_rk45_grad_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_rk45_grad_test.cpp
@@ -38,9 +38,9 @@ class sho_functor {
   // parameters
   // double data
   // integer data
-  operator()(const T0& t_in, const std::vector<T1>& y_in, std::ostream* msgs,
+  operator()(const T0& t_in, const std::vector<T1>& y_in,
              const std::vector<T2>& theta, const std::vector<double>& x,
-             const std::vector<int>& x_int) const {
+             const std::vector<int>& x_int, std::ostream* msgs) const {
     if (y_in.size() != 2)
       throw std::domain_error("Functor called with inconsistent state");
 
diff --git a/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
index 3ef7fa9d5ee..1847bc7bb8d 100644
--- a/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_rk45_rev_test.cpp
@@ -206,7 +206,7 @@ TEST(StanAgradRevOde_integrate_ode_rk45, time_steps_as_param_AD) {
           } else {
             std::vector<double> y0(res_d.begin(), res_d.begin() + ns);
             EXPECT_FLOAT_EQ(g[k],
-                            ode(ts[i].val(), y0, msgs, theta, x, x_int)[j]);
+                            ode(ts[i].val(), y0, theta, x, x_int, msgs)[j]);
           }
         }
         stan::math::set_zero_all_adjoints();
diff --git a/test/unit/math/rev/functor/integrate_ode_std_vector_interface_adapter_test.cpp b/test/unit/math/rev/functor/integrate_ode_std_vector_interface_adapter_test.cpp
index 5eb1fc098ea..f8611f7f57a 100644
--- a/test/unit/math/rev/functor/integrate_ode_std_vector_interface_adapter_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_std_vector_interface_adapter_test.cpp
@@ -20,7 +20,7 @@ TEST(StanMathRev, vd) {
   double t = 1.0;
 
   Eigen::Matrix<var, Eigen::Dynamic, 1> out1
-      = stan::math::to_vector(harm_osc(t, y, nullptr, theta, x, x_int));
+      = stan::math::to_vector(harm_osc(t, y, theta, x, x_int, nullptr));
   Eigen::Matrix<var, Eigen::Dynamic, 1> out2
       = harm_osc_adapted(t, stan::math::to_vector(y), nullptr, theta, x, x_int);
 
@@ -56,7 +56,7 @@ TEST(StanMathRev, dv) {
   double t = 1.0;
 
   Eigen::Matrix<var, Eigen::Dynamic, 1> out1
-      = stan::math::to_vector(harm_osc(t, y, nullptr, theta, x, x_int));
+      = stan::math::to_vector(harm_osc(t, y, theta, x, x_int, nullptr));
   Eigen::Matrix<var, Eigen::Dynamic, 1> out2
       = harm_osc_adapted(t, stan::math::to_vector(y), nullptr, theta, x, x_int);
 
@@ -92,7 +92,7 @@ TEST(StanMathRev, vv) {
   double t = 1.0;
 
   Eigen::Matrix<var, Eigen::Dynamic, 1> out1
-      = stan::math::to_vector(harm_osc(t, y, nullptr, theta, x, x_int));
+      = stan::math::to_vector(harm_osc(t, y, theta, x, x_int, nullptr));
   Eigen::Matrix<var, Eigen::Dynamic, 1> out2
       = harm_osc_adapted(t, stan::math::to_vector(y), nullptr, theta, x, x_int);
 

From 0d2e975299735b3c43c457153ec5a01f3dabe9ec Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Fri, 10 Jul 2020 17:01:37 -0400
Subject: [PATCH 187/189] [Jenkins] auto-formatting by clang-format version
 6.0.0-1ubuntu2 (tags/RELEASE_600/final)

---
 test/unit/math/rev/functor/cvodes_utils_test.cpp    | 13 ++++++++-----
 .../functor/integrate_ode_cvodes_grad_rev_test.cpp  | 12 ++++++------
 2 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/test/unit/math/rev/functor/cvodes_utils_test.cpp b/test/unit/math/rev/functor/cvodes_utils_test.cpp
index b39e13d85f6..31ef4c77108 100644
--- a/test/unit/math/rev/functor/cvodes_utils_test.cpp
+++ b/test/unit/math/rev/functor/cvodes_utils_test.cpp
@@ -6,8 +6,9 @@
 
 struct Inverse {
   template <typename T0, typename T_y>
-  inline Eigen::Matrix<stan::return_type_t<T_y>, Eigen::Dynamic, 1>
-  operator()(const T0& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y, std::ostream* msgs) const {
+  inline Eigen::Matrix<stan::return_type_t<T_y>, Eigen::Dynamic, 1> operator()(
+      const T0& t, const Eigen::Matrix<T_y, Eigen::Dynamic, 1>& y,
+      std::ostream* msgs) const {
     Eigen::Matrix<T_y, Eigen::Dynamic, 1> out(1);
     out(0) = 1.0 / (y(0) - 1.0);
     return out;
@@ -19,8 +20,10 @@ TEST(StanMath, cvodes_error_handler) {
   int t0 = 0;
   std::vector<double> ts = {0.45, 1.1};
 
-  std::string msg = "CVODES: CVode Internal t = 0 and h = 0 are such that t + h = t on the next step";
-  
+  std::string msg
+      = "CVODES: CVode Internal t = 0 and h = 0 are such that t + h = t on the "
+        "next step";
+
   EXPECT_THROW_MSG(stan::math::ode_bdf(Inverse(), y0, t0, ts, nullptr),
-    		   std::domain_error, msg);
+                   std::domain_error, msg);
 }
diff --git a/test/unit/math/rev/functor/integrate_ode_cvodes_grad_rev_test.cpp b/test/unit/math/rev/functor/integrate_ode_cvodes_grad_rev_test.cpp
index 22dd71bfd86..8794d29903d 100644
--- a/test/unit/math/rev/functor/integrate_ode_cvodes_grad_rev_test.cpp
+++ b/test/unit/math/rev/functor/integrate_ode_cvodes_grad_rev_test.cpp
@@ -36,12 +36,12 @@ class sho_functor {
  public:
   template <typename T0, typename T1, typename T2>
   inline std::vector<stan::return_type_t<T1, T2>> operator()(
-      const T0& t_in,                         // time
-      const std::vector<T1>& y_in,            // state
-      const std::vector<T2>& theta,           // parameters
-      const std::vector<double>& x,           // double data
-      const std::vector<int>& x_int,          // integer data
-      std::ostream* msgs) const {             // error stream
+      const T0& t_in,                 // time
+      const std::vector<T1>& y_in,    // state
+      const std::vector<T2>& theta,   // parameters
+      const std::vector<double>& x,   // double data
+      const std::vector<int>& x_int,  // integer data
+      std::ostream* msgs) const {     // error stream
     if (y_in.size() != 2)
       throw std::domain_error("Functor called with inconsistent state");
 

From 1908f1cbeb60d765e0cc28914c43a66001b8e4ae Mon Sep 17 00:00:00 2001
From: Ben <bbbales2@gmail.com>
Date: Mon, 13 Jul 2020 12:04:37 -0400
Subject: [PATCH 188/189] Fixed error message printing with too much work and
 extended tests to catch it (design-doc #19)

---
 stan/math/prim/functor/ode_rk45.hpp                    | 2 +-
 test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp | 2 +-
 test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp | 2 +-
 test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp  | 2 +-
 test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp   | 2 +-
 test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp    | 2 +-
 test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp   | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/stan/math/prim/functor/ode_rk45.hpp b/stan/math/prim/functor/ode_rk45.hpp
index d0b561d503e..b85a705553b 100644
--- a/stan/math/prim/functor/ode_rk45.hpp
+++ b/stan/math/prim/functor/ode_rk45.hpp
@@ -132,7 +132,7 @@ ode_rk45_tol_impl(const char* function_name, const F& f,
         std::end(ts_vec), step_size, filtered_observer,
         max_step_checker(max_num_steps));
   } catch (const no_progress_error& e) {
-    throw_domain_error("integrate_ode_rk45", "", ts_vec[time_index + 1],
+    throw_domain_error(function_name, "", ts_vec[time_index + 1],
                        "Failed to integrate to next output time (",
                        ") in less than max_num_steps steps");
   }
diff --git a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
index b6d87c055a6..4d9a52cc718 100644
--- a/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
+++ b/test/unit/math/prim/functor/ode_rk45_tol_prim_test.cpp
@@ -444,5 +444,5 @@ TEST(ode_rk45_tol_prim, too_much_work) {
   EXPECT_THROW_MSG(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
                                             100, nullptr, a),
                    std::domain_error,
-                   "Failed to integrate to next output time");
+                   "ode_rk45_tol:  Failed to integrate to next output time");
 }
diff --git a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
index b8c2bc8158b..b21f7a15142 100644
--- a/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_tol_prim_test.cpp
@@ -444,5 +444,5 @@ TEST(ode_adams_tol_prim, too_much_work) {
   EXPECT_THROW_MSG(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
                                              100, nullptr, a),
                    std::domain_error,
-                   "Failed to integrate to next output time");
+                   "ode_adams_tol:  Failed to integrate to next output time");
 }
diff --git a/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
index 93e50740061..d92be94a14b 100644
--- a/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_adams_tol_rev_test.cpp
@@ -586,5 +586,5 @@ TEST(StanMathOde_ode_adams_tol, too_much_work) {
   EXPECT_THROW_MSG(stan::math::ode_adams_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
                                              100, nullptr, a),
                    std::domain_error,
-                   "Failed to integrate to next output time");
+                   "ode_adams_tol:  Failed to integrate to next output time");
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
index dde9446c438..4497e90b773 100644
--- a/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_tol_prim_test.cpp
@@ -442,5 +442,5 @@ TEST(ode_bdf_tol_prim, too_much_work) {
   EXPECT_THROW_MSG(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
                                            100, nullptr, a),
                    std::domain_error,
-                   "Failed to integrate to next output time");
+                   "ode_bdf_tol:  Failed to integrate to next output time");
 }
diff --git a/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
index 1aec32ab9cc..c1536d3ddd2 100644
--- a/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_bdf_tol_rev_test.cpp
@@ -586,5 +586,5 @@ TEST(StanMathOde_ode_bdf_tol, too_much_work) {
   EXPECT_THROW_MSG(stan::math::ode_bdf_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
                                            100, nullptr, a),
                    std::domain_error,
-                   "Failed to integrate to next output time");
+                   "ode_bdf_tol:  Failed to integrate to next output time");
 }
diff --git a/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp b/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
index 05bb245c1e1..7db3e1e2aee 100644
--- a/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
+++ b/test/unit/math/rev/functor/ode_rk45_tol_rev_test.cpp
@@ -586,5 +586,5 @@ TEST(StanMathOde_ode_rk45_tol, too_much_work) {
   EXPECT_THROW_MSG(stan::math::ode_rk45_tol(CosArg1(), y0, t0, ts, 1e-6, 1e-6,
                                             100, nullptr, a),
                    std::domain_error,
-                   "Failed to integrate to next output time");
+                   "ode_rk45_tol:  Failed to integrate to next output time");
 }

From bec1c2a7d7144e5ee68f2ce6d474e2d8cdb28785 Mon Sep 17 00:00:00 2001
From: Rok Cesnovar <rok.cesnovar@fri.uni-lj.si>
Date: Wed, 15 Jul 2020 09:02:06 +0200
Subject: [PATCH 189/189] comment-out dont run async tests

---
 Jenkinsfile | 50 +++++++++++++++++++++++++-------------------------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index 07d547b598c..04825b792ff 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -248,31 +248,31 @@ pipeline {
                     }
                     post { always { retry(3) { deleteDir() } } }
                 }
-                stage('OpenCL tests async') {
-                    agent { label "gpu-async" }
-                    when {
-                        expression {
-                            runGpuAsync
-                        }
-                    }
-                    steps {
-                        deleteDir()
-                        unstash 'MathSetup'
-                        sh "echo CXX=${env.CXX} -Werror > make/local"
-                        sh "echo STAN_OPENCL=true>> make/local"
-                        sh "echo OPENCL_PLATFORM_ID=0>> make/local"
-                        sh "echo OPENCL_DEVICE_ID=${OPENCL_DEVICE_ID}>> make/local"
-                        sh "make -j${env.PARALLEL} test-headers"
-                        runTests("test/unit/math/opencl")
-                        runTests("test/unit/math/prim/fun/gp_exp_quad_cov_test")
-                        runTests("test/unit/math/prim/fun/mdivide_left_tri_test")
-                        runTests("test/unit/math/prim/fun/mdivide_right_tri_test")
-                        runTests("test/unit/math/prim/fun/multiply_test")
-                        runTests("test/unit/math/rev/fun/mdivide_left_tri_test")
-                        runTests("test/unit/math/rev/fun/multiply_test")
-                    }
-                    post { always { retry(3) { deleteDir() } } }
-                }
+                // stage('OpenCL tests async') {
+                //     agent { label "gpu-async" }
+                //     when {
+                //         expression {
+                //             runGpuAsync
+                //         }
+                //     }
+                //     steps {
+                //         deleteDir()
+                //         unstash 'MathSetup'
+                //         sh "echo CXX=${env.CXX} -Werror > make/local"
+                //         sh "echo STAN_OPENCL=true>> make/local"
+                //         sh "echo OPENCL_PLATFORM_ID=0>> make/local"
+                //         sh "echo OPENCL_DEVICE_ID=${OPENCL_DEVICE_ID}>> make/local"
+                //         sh "make -j${env.PARALLEL} test-headers"
+                //         runTests("test/unit/math/opencl")
+                //         runTests("test/unit/math/prim/fun/gp_exp_quad_cov_test")
+                //         runTests("test/unit/math/prim/fun/mdivide_left_tri_test")
+                //         runTests("test/unit/math/prim/fun/mdivide_right_tri_test")
+                //         runTests("test/unit/math/prim/fun/multiply_test")
+                //         runTests("test/unit/math/rev/fun/mdivide_left_tri_test")
+                //         runTests("test/unit/math/rev/fun/multiply_test")
+                //     }
+                //     post { always { retry(3) { deleteDir() } } }
+                // }
                 stage('Distribution tests') {
                     agent { label "distribution-tests" }
                     steps {