stan-dev · SteveBronder · Jul 27, 2021 · Jul 13, 2021 · Jul 13, 2021 · Jul 14, 2021
diff --git a/stan/math/fwd/fun/accumulator.hpp b/stan/math/fwd/fun/accumulator.hpp
@@ -2,9 +2,10 @@
 #define STAN_MATH_FWD_FUN_ACCUMULATOR_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/accumulator.hpp>
+#include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/fun/sum.hpp>
+#include <stan/math/prim/fun/accumulator.hpp>
 #include <vector>
 #include <type_traits>
 
@@ -37,7 +38,7 @@ class accumulator<fvar<T>> {
    * @tparam S Type of argument
    * @param x Value to add
    */
-  template <typename S, require_stan_scalar_t<S>* = nullptr>
+  template <typename S, typename = require_stan_scalar_t<S>>
   inline void add(S x) {
     buf_.push_back(x);
   }
@@ -63,18 +64,13 @@ class accumulator<fvar<T>> {
    * @tparam S Type of value to recursively add.
    * @param xs Vector of entries to add
    */
-  template <typename S, require_container_t<S>* = nullptr>
+  template <typename S>
   inline void add(const std::vector<S>& xs) {
     for (size_t i = 0; i < xs.size(); ++i) {
       this->add(xs[i]);
     }
   }
 
-  template <typename S, require_not_container_t<S>* = nullptr>
-  inline void add(const std::vector<S>& xs) {
-    buf_.push_back(stan::math::sum(xs));
-  }
-
   /**
    * Return the sum of the accumulated values.
    *

diff --git a/stan/math/mix.hpp b/stan/math/mix.hpp
@@ -1,14 +1,14 @@
 #ifndef STAN_MATH_MIX_HPP
 #define STAN_MATH_MIX_HPP
 
-#ifdef STAN_OPENCL
-#include <stan/math/opencl/rev.hpp>
-#endif
-
 #include <stan/math/mix/meta.hpp>
 #include <stan/math/mix/fun.hpp>
 #include <stan/math/mix/functor.hpp>
 
+#ifdef STAN_OPENCL
+#include <stan/math/opencl/rev.hpp>
+#endif
+
 #include <stan/math/rev/core.hpp>
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/fun.hpp>

diff --git a/stan/math/prim/fun/accumulator.hpp b/stan/math/prim/fun/accumulator.hpp
@@ -1,14 +1,9 @@
 #ifndef STAN_MATH_PRIM_FUN_ACCUMULATOR_HPP
 #define STAN_MATH_PRIM_FUN_ACCUMULATOR_HPP
 
-#include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/Eigen.hpp>
+#include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/fun/sum.hpp>
-
-#ifdef STAN_OPENCL
-#include <stan/math/opencl/prim.hpp>
-#endif
-
 #include <vector>
 #include <type_traits>
 
@@ -41,13 +36,14 @@ class accumulator {
    * @tparam S Type of argument
    * @param x Value to add
    */
-  template <typename S, typename = require_arithmetic_t<S>>
+  template <typename S, typename = require_stan_scalar_t<S>>
   inline void add(S x) {
     buf_.push_back(x);
   }
 
   /**
-   * Sum each entry of the matrix and then add the sum to the buffer.
+   * Add each entry in the specified matrix, vector, or row vector
+   * of values to the buffer.
    *
    * @tparam S type of the matrix
    * @param m Matrix of values to add
@@ -60,24 +56,21 @@ class accumulator {
   /**
    * Recursively add each entry in the specified standard vector
    * to the buffer.  This will allow vectors of primitives,
-   * autodiff variables to be added.
+   * autodiff variables to be added; if the vector entries
+   * are collections, their elements are recursively added.
    *
    * @tparam S Type of value to recursively add.
    * @param xs Vector of entries to add
    */
-  template <typename S, require_container_t<S>* = nullptr>
+  template <typename S>
   inline void add(const std::vector<S>& xs) {
     for (size_t i = 0; i < xs.size(); ++i) {
       this->add(xs[i]);
     }
   }
 
-  template <typename S, require_not_container_t<S>* = nullptr>
-  inline void add(const std::vector<S>& xs) {
-    buf_.push_back(stan::math::sum(xs));
-  }
-
 #ifdef STAN_OPENCL
+
   /**
    * Sum each entry and then push to the buffer.
    * @tparam S A Type inheriting from `matrix_cl_base`
@@ -88,16 +81,7 @@ class accumulator {
   inline void add(const S& xs) {
     buf_.push_back(stan::math::sum(xs));
   }
-  /**
-   * Sum each entry and then push to the buffer.
-   * @tparam S A Type inheriting from `matrix_cl_base`
-   * @param x An `std::vector` with inner type OpenCL matrix
-   */
-  template <typename S,
-            require_all_kernel_expressions_and_none_scalar_t<S>* = nullptr>
-  inline void add(const std::vector<S>& xs) {
-    buf_.push_back(stan::math::sum(xs));
-  }
+
 #endif
 
   /**

diff --git a/stan/math/prim/fun/sum.hpp b/stan/math/prim/fun/sum.hpp
@@ -29,7 +29,7 @@ inline T sum(T&& m) {
  * @param m Standard vector to sum.
  * @return Sum of elements.
  */
-template <typename T>
+template <typename T, require_not_var_t<T>* = nullptr>
 inline T sum(const std::vector<T>& m) {
   return std::accumulate(m.begin(), m.end(), T{0});
 }

diff --git a/stan/math/rev/fun.hpp b/stan/math/rev/fun.hpp
@@ -3,11 +3,6 @@
 
 #include <stan/math/prim/fun/Eigen.hpp>
 
-#include <stan/math/prim/err.hpp>
-#include <stan/math/prim/fun.hpp>
-#include <stan/math/prim/functor.hpp>
-#include <stan/math/prim/meta.hpp>
-
 #include <stan/math/rev/fun/LDLT_factor.hpp>
 #include <stan/math/rev/fun/Phi.hpp>
 #include <stan/math/rev/fun/Phi_approx.hpp>

diff --git a/stan/math/rev/fun/accumulator.hpp b/stan/math/rev/fun/accumulator.hpp
@@ -2,15 +2,9 @@
 #define STAN_MATH_REV_FUN_ACCUMULATOR_HPP
 
 #include <stan/math/prim/fun/Eigen.hpp>
-#include <stan/math/prim/fun/accumulator.hpp>
 #include <stan/math/rev/meta.hpp>
-#include <stan/math/rev/core.hpp>
 #include <stan/math/rev/fun/sum.hpp>
-
-#ifdef STAN_OPENCL
-#include <stan/math/opencl/rev.hpp>
-#endif
-
+#include <stan/math/prim/fun/accumulator.hpp>
 #include <vector>
 #include <type_traits>
 
@@ -30,7 +24,7 @@ namespace math {
 template <>
 class accumulator<var> {
  private:
-  std::vector<var> buf_;
+  std::vector<var, arena_allocator<var>> buf_;
 
  public:
   /**
@@ -43,7 +37,7 @@ class accumulator<var> {
    * @tparam S Type of argument
    * @param x Value to add
    */
-  template <typename S, require_stan_scalar_t<S>* = nullptr>
+  template <typename S, typename = require_stan_scalar_t<S>>
   inline void add(S x) {
     buf_.push_back(x);
   }
@@ -66,26 +60,10 @@ class accumulator<var> {
    * autodiff variables to be added; if the vector entries
    * are collections, their elements are recursively added.
    *
-   * @tparam S A standard vector holding non-container elements
+   * @tparam S Type of value to recursively add.
    * @param xs Vector of entries to add
    */
-  template <typename S,
-            require_all_not_t<is_container<S>, is_var_matrix<S>>* = nullptr>
-  inline void add(const std::vector<S>& xs) {
-    buf_.push_back(stan::math::sum(xs));
-  }
-
-  /**
-   * Recursively add each entry in the specified standard vector
-   * to the buffer.  This will allow vectors of primitives,
-   * autodiff variables to be added; if the vector entries
-   * are collections, their elements are recursively added.
-   *
-   * @tparam S A standard vector holding container elements
-   * @param xs Vector of entries to add
-   */
-  template <typename S,
-            require_any_t<is_container<S>, is_var_matrix<S>>* = nullptr>
+  template <typename S>
   inline void add(const std::vector<S>& xs) {
     for (size_t i = 0; i < xs.size(); ++i) {
       this->add(xs[i]);
@@ -96,33 +74,32 @@ class accumulator<var> {
   /**
    * Sum each entry and then push to the buffer.
    * @tparam S A Type inheriting from `matrix_cl_base`
-   * @param x A `var_value` with inner type OpenCL matrix
+   * @param x An OpenCL matrix
    */
   template <typename S,
             require_all_kernel_expressions_and_none_scalar_t<S>* = nullptr>
-  inline void add(const var_value<S>& x) {
-    buf_.push_back(stan::math::sum(x));
+  inline void add(const var_value<S>& xs) {
+    buf_.push_back(stan::math::sum(xs));
   }
+
   /**
    * Sum each entry and then push to the buffer.
    * @tparam S A Type inheriting from `matrix_cl_base`
-   * @param x An `std::vector` holding a `var_value` with inner type OpenCL
-   * matrix
+   * @param x An OpenCL matrix
    */
   template <typename S,
             require_all_kernel_expressions_and_none_scalar_t<S>* = nullptr>
-  inline void add(const std::vector<var_value<S>>& xs) {
+  inline void add(const S& xs) {
     buf_.push_back(stan::math::sum(xs));
   }
 
 #endif
-
   /**
    * Return the sum of the accumulated values.
    *
    * @return Sum of accumulated values.
    */
-  inline var sum() const { return stan::math::sum(buf_); }
+  inline var sum() const noexcept { return stan::math::sum(buf_); }
 };
 
 }  // namespace math

diff --git a/stan/math/rev/fun/sum.hpp b/stan/math/rev/fun/sum.hpp
@@ -58,11 +58,19 @@ class sum_v_vari : public vari {
  * @param m Vector.
  * @return Sum of vector entries.
  */
-inline var sum(const std::vector<var>& m) {
-  if (m.empty()) {
+template <typename Alloc>
+inline var sum(const std::vector<var, Alloc>& m) {
+  if (unlikely(m.empty())) {
     return 0.0;
+  } else {
+    auto arena_m = to_arena(m);
+    return make_callback_var(stan::math::sum(as_array_or_scalar(arena_m).val()),
+                             [arena_m](auto& vi) mutable {
+                               for (auto& x_i : arena_m) {
+                                 x_i.adj() += vi.adj();
+                               }
+                             });
   }
-  return var(new sum_v_vari(m));
 }
 
 /**

diff --git a/test/unit/math/mix/fun/ldexp_test.cpp b/test/unit/math/mix/fun/ldexp_test.cpp
@@ -1,5 +1,4 @@
 #include <test/unit/math/test_ad.hpp>
-#include <stan/math/prim.hpp>
 
 TEST(mathMixScalFun, ldexp) {
   auto f = [](const auto& x1) { return stan::math::ldexp(x1, 5); };

diff --git a/test/unit/math/mix/meta/require_generics_test.cpp b/test/unit/math/mix/meta/require_generics_test.cpp
@@ -1,6 +1,4 @@
-#include <stan/math/fwd.hpp>
-#include <stan/math/rev.hpp>
-#include <stan/math/prim.hpp>
+#include <test/unit/math/test_ad.hpp>
 #include <test/unit/math/require_util.hpp>
 #include <gtest/gtest.h>
 #include <type_traits>

diff --git a/test/unit/math/mix/prob/von_mises_cdf_test.cpp b/test/unit/math/mix/prob/von_mises_cdf_test.cpp
@@ -1,4 +1,3 @@
-#include <stan/math/prim.hpp>
 #include <test/unit/math/test_ad.hpp>
 #include <limits>
 

diff --git a/test/unit/math/opencl/rev/accumulator_test.cpp b/test/unit/math/opencl/rev/accumulator_test.cpp
diff --git a/test/unit/math/rev/core/gradable.hpp b/test/unit/math/rev/core/gradable.hpp
@@ -1,8 +1,7 @@
 #ifndef TEST_UNIT_MATH_REV_CORE_GRADABLE_HPP
 #define TEST_UNIT_MATH_REV_CORE_GRADABLE_HPP
 
-#include <stan/math.hpp>
-#include <stan/math/prim.hpp>
+#include <stan/math/rev.hpp>
 #include <stan/math/rev/fun/quad_form.hpp>
 #include <test/unit/math/rev/fun/util.hpp>
 #include <vector>

diff --git a/test/unit/math/rev/fun/accumulator_test.cpp b/test/unit/math/rev/fun/accumulator_test.cpp
@@ -1,6 +1,6 @@
 #include <stan/math/rev.hpp>
-#include <gtest/gtest.h>
 #include <test/unit/math/rev/util.hpp>
+#include <gtest/gtest.h>
 #include <vector>
 
 // test sum of first n numbers for sum of a

diff --git a/test/unit/math/rev/fun/eigenvalues_sym_test.cpp b/test/unit/math/rev/fun/eigenvalues_sym_test.cpp
@@ -1,4 +1,4 @@
-#include <stan/math/prim.hpp>
+#include <stan/math/rev.hpp>
 #include <stan/math/rev/fun/eigenvalues_sym.hpp>
 #include <stan/math/rev/fun/sum.hpp>
 #include <stan/math/rev/fun/log.hpp>

diff --git a/test/unit/math/rev/fun/eigenvectors_sym_test.cpp b/test/unit/math/rev/fun/eigenvectors_sym_test.cpp
@@ -1,3 +1,4 @@
+#include <stan/math/rev.hpp>
 #include <stan/math/prim.hpp>
 #include <stan/math/rev/fun/eigenvectors_sym.hpp>
 #include <stan/math/rev/fun/sum.hpp>

diff --git a/test/unit/math/rev/fun/lbeta_test.cpp b/test/unit/math/rev/fun/lbeta_test.cpp
@@ -1,5 +1,5 @@
-#include <stan/math/prim.hpp>
 #include <stan/math/rev.hpp>
+#include <stan/math/prim.hpp>
 #include <stan/math/rev/core/nested_rev_autodiff.hpp>
 #include <test/unit/math/expect_near_rel.hpp>
 #include <gtest/gtest.h>

diff --git a/test/unit/math/rev/fun/promote_elements_test.cpp b/test/unit/math/rev/fun/promote_elements_test.cpp
@@ -1,4 +1,4 @@
-#include <stan/math/rev/core.hpp>
+#include <stan/math/rev.hpp>
 #include <stan/math/prim.hpp>
 #include <boost/typeof/typeof.hpp>
 #include <gtest/gtest.h>

diff --git a/test/unit/math/rev/fun/singular_values_test.cpp b/test/unit/math/rev/fun/singular_values_test.cpp
@@ -1,3 +1,4 @@
+#include <stan/math/rev.hpp>
 #include <stan/math/prim.hpp>
 #include <stan/math/rev/fun/singular_values.hpp>
 #include <stan/math/rev/fun/sum.hpp>