Move serializer definition into Math proper

Author: andrjohns

stan/math/fwd/functor/fvar_finite_diff.hpp

@@ -6,7 +6,7 @@
 #include <stan/math/prim/functor/finite_diff_gradient_auto.hpp>
 #include <stan/math/prim/fun/value_of.hpp>
 #include <stan/math/prim/fun/sum.hpp>
-#include <test/unit/math/serializer.hpp>
+#include <stan/math/prim/fun/serializer.hpp>
 
 namespace stan {
 namespace math {
@@ -66,13 +66,13 @@ auto fvar_finite_diff(const F& func, const TArgs&... args) {
   using FvarT = return_type_t<TArgs...>;
   using FvarInnerT = typename FvarT::Scalar;
 
-  auto serialised_args = stan::test::serialize<FvarInnerT>(value_of(args)...);
+  auto serialised_args = serialize<FvarInnerT>(value_of(args)...);
 
   // Create a 'wrapper' functor which will take the flattened column-vector
   // and transform it to individual arguments which are passed to the
   // user-provided functor
   auto serial_functor = [&](const auto& v) {
-    return func(stan::test::to_deserializer(v).read(args)...);
+    return func(to_deserializer(v).read(args)...);
   };
 
   FvarInnerT rtn_value;
@@ -84,7 +84,7 @@ auto fvar_finite_diff(const F& func, const TArgs&... args) {
   // Use a fold-expression to aggregate tangents for input arguments
   (void)std::initializer_list<int>{
       (rtn_grad += internal::aggregate_tangent(
-           stan::test::to_deserializer(grad).read(args), args),
+           to_deserializer(grad).read(args), args),
        0)...};
 
   return FvarT(rtn_value, rtn_grad);

stan/math/fwd/functor/integrate_1d.hpp

@@ -5,6 +5,7 @@
 #include <stan/math/prim/functor/integrate_1d.hpp>
 #include <stan/math/prim/fun/value_of.hpp>
 #include <stan/math/prim/meta/forward_as.hpp>
+#include <stan/math/prim/functor/apply.hpp>
 #include <stan/math/fwd/functor/fvar_finite_diff.hpp>
 
 namespace stan {

stan/math/prim/fun.hpp

@@ -305,6 +305,7 @@
 #include <stan/math/prim/fun/scaled_add.hpp>
 #include <stan/math/prim/fun/sd.hpp>
 #include <stan/math/prim/fun/segment.hpp>
+#include <stan/math/prim/fun/serializer.hpp>
 #include <stan/math/prim/fun/sign.hpp>
 #include <stan/math/prim/fun/signbit.hpp>
 #include <stan/math/prim/fun/simplex_constrain.hpp>

test/unit/math/serializer.hpp stan/math/prim/fun/serializer.hpptest/unit/math/serializer.hpp renamed to stan/math/prim/fun/serializer.hpp

@@ -1,13 +1,13 @@
-#ifndef TEST_UNIT_MATH_SERIALIZER_HPP
-#define TEST_UNIT_MATH_SERIALIZER_HPP
+#ifndef STAN_MATH_PRIM_FUN_SERIALIZER_HPP
+#define STAN_MATH_PRIM_FUN_SERIALIZER_HPP
 
-#include <stan/math.hpp>
+#include <stan/math/prim/fun/to_vector.hpp>
 #include <complex>
 #include <string>
 #include <vector>
 
 namespace stan {
-namespace test {
+namespace math {
 
 /**
  * A class to store a sequence of values which can be deserialized
@@ -47,7 +47,7 @@ struct deserializer {
    * @param vals values to deserialize
    */
   explicit deserializer(const Eigen::Matrix<T, -1, 1>& v_vals)
-      : position_(0), vals_(math::to_array_1d(v_vals)) {}
+      : position_(0), vals_(to_array_1d(v_vals)) {}
 
   /**
    * Read a scalar conforming to the shape of the specified argument,
@@ -94,8 +94,8 @@ struct deserializer {
    */
   template <typename U, require_std_vector_t<U>* = nullptr,
             require_not_st_complex<U>* = nullptr>
-  typename stan::math::promote_scalar_type<T, U>::type read(const U& x) {
-    typename stan::math::promote_scalar_type<T, U>::type y;
+  typename promote_scalar_type<T, U>::type read(const U& x) {
+    typename promote_scalar_type<T, U>::type y;
     y.reserve(x.size());
     for (size_t i = 0; i < x.size(); ++i)
       y.push_back(read(x[i]));
@@ -113,9 +113,9 @@ struct deserializer {
    * @return deserialized value with shape and size matching argument
    */
   template <typename U, require_std_vector_st<is_complex, U>* = nullptr>
-  typename stan::math::promote_scalar_type<std::complex<T>, U>::type read(
+  typename promote_scalar_type<std::complex<T>, U>::type read(
       const U& x) {
-    typename stan::math::promote_scalar_type<std::complex<T>, U>::type y;
+    typename promote_scalar_type<std::complex<T>, U>::type y;
     y.reserve(x.size());
     for (size_t i = 0; i < x.size(); ++i)
       y.push_back(read(x[i]));
@@ -258,7 +258,7 @@ struct serializer {
    * @return serialized values
    */
   const Eigen::Matrix<T, -1, 1>& vector_vals() {
-    return math::to_vector(vals_);
+    return to_vector(vals_);
   }
 };
 
@@ -338,7 +338,7 @@ std::vector<real_return_t<T>> serialize_return(const T& x) {
  */
 template <typename... Ts>
 Eigen::VectorXd serialize_args(const Ts... xs) {
-  return math::to_vector(serialize<double>(xs...));
+  return to_vector(serialize<double>(xs...));
 }
 
 }  // namespace test

test/unit/math/serializer_test.cpp

@@ -1,10 +1,10 @@
-#include <test/unit/math/serializer.hpp>
+#include <stan/math/prim/fun/serializer.hpp>
 #include <gtest/gtest.h>
 #include <complex>
 #include <vector>
 
 TEST(testUnitMathSerializer, serializer_deserializer) {
-  stan::test::serializer<double> s;
+  stan::math::serializer<double> s;
 
   s.write(3.2);
   s.write(-1);
@@ -30,7 +30,7 @@ TEST(testUnitMathSerializer, serializer_deserializer) {
   for (size_t i = 0; i < expected.size(); ++i)
     EXPECT_EQ(expected[i], s.vals_[i]);
 
-  stan::test::deserializer<double> d = stan::test::to_deserializer(s.vals_);
+  stan::math::deserializer<double> d = stan::math::to_deserializer(s.vals_);
 
   EXPECT_EQ(3.2, d.read(0.0));
   EXPECT_EQ(-1, d.read(0.0));
@@ -58,15 +58,15 @@ TEST(testUnitMathSerializer, serializer_deserializer) {
 }
 
 TEST(testUnitMathSerializer, serialize) {
-  std::vector<double> xs = stan::test::serialize<double>();
+  std::vector<double> xs = stan::math::serialize<double>();
   EXPECT_EQ(0, xs.size());
 
   double a = 2;
   std::complex<double> b(1, 2);
   std::vector<double> c{3, 4, 5};
   Eigen::MatrixXd d(2, 3);
   d << -1, -2, -3, -4, -5, -6;
-  std::vector<double> ys = stan::test::serialize<double>(a, b, c, d);
+  std::vector<double> ys = stan::math::serialize<double>(a, b, c, d);
 
   std::vector<double> expected{2, 1, 2, 3, 4, 5, -1, -4, -2, -5, -3, -6};
   for (size_t i = 0; i < expected.size(); ++i)

test/unit/math/test_ad.hpp

@@ -6,7 +6,7 @@
 #include <test/unit/math/ad_tolerances.hpp>
 #include <test/unit/math/is_finite.hpp>
 #include <test/unit/math/expect_near_rel.hpp>
-#include <test/unit/math/serializer.hpp>
+#include <stan/math/prim/fun/serializer.hpp>
 #include <test/unit/math/test_ad_matvar.hpp>
 #include <test/unit/util.hpp>
 #include <gtest/gtest.h>

test/unit/math/test_ad_matvar.hpp

@@ -6,7 +6,7 @@
 #include <test/unit/math/ad_tolerances.hpp>
 #include <test/unit/math/is_finite.hpp>
 #include <test/unit/math/expect_near_rel.hpp>
-#include <test/unit/math/serializer.hpp>
+#include <stan/math/prim/fun/serializer.hpp>
 #include <test/unit/util.hpp>
 #include <gtest/gtest.h>
 #include <algorithm>