serializer.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_FUN_SERIALIZER_HPP
#define STAN_MATH_PRIM_FUN_SERIALIZER_HPP
 
#include <stan/math/prim/meta/promote_scalar_type.hpp>
#include <stan/math/prim/fun/to_vector.hpp>
#include <stan/math/prim/fun/to_array_1d.hpp>
#include <complex>
#include <string>
#include <vector>
 
namespace stan {
namespace math {
 
template <typename T>
struct deserializer {
  typedef T scalar_t;
 
  size_t position_;
 
  const std::vector<T> vals_;
 
  explicit deserializer(const std::vector<T>& vals)
      : position_(0), vals_(vals) {}
 
  explicit deserializer(const Eigen::Matrix<T, -1, 1>& v_vals)
      : position_(0), vals_(to_array_1d(v_vals)) {}
 
  template <typename U, require_stan_scalar_t<U>* = nullptr,
            require_not_complex_t<U>* = nullptr>
  T read(const U& x) {
    return vals_[position_++];
  }
 
  template <typename U>
  std::complex<T> read(const std::complex<U>& x) {
    T re = read(x.real());
    T im = read(x.imag());
    return {re, im};
  }
 
  template <typename U, require_std_vector_t<U>* = nullptr,
            require_not_st_complex<U>* = nullptr>
  promote_scalar_t<T, U> read(const U& x) {
    promote_scalar_t<T, U> y;
    y.reserve(x.size());
    for (size_t i = 0; i < x.size(); ++i)
      y.push_back(read(x[i]));
    return y;
  }
 
  template <typename U, require_std_vector_st<is_complex, U>* = nullptr>
  promote_scalar_t<std::complex<T>, U> read(const U& x) {
    promote_scalar_t<std::complex<T>, U> y;
    y.reserve(x.size());
    for (size_t i = 0; i < x.size(); ++i)
      y.push_back(read(x[i]));
    return y;
  }
 
  template <typename U, int R, int C>
  Eigen::Matrix<T, R, C> read(const Eigen::Matrix<U, R, C>& x) {
    Eigen::Matrix<T, R, C> y(x.rows(), x.cols());
    for (int j = 0; j < x.cols(); ++j) {
      for (int i = 0; i < x.rows(); ++i) {
        y(i + j * x.rows()) = read(x(i, j));
      }
    }
    return y;
  }
 
  template <typename U, int R, int C>
  Eigen::Matrix<std::complex<T>, R, C> read(
      const Eigen::Matrix<std::complex<U>, R, C>& x) {
    Eigen::Matrix<std::complex<T>, R, C> y(x.rows(), x.cols());
    for (int j = 0; j < x.cols(); ++j) {
      for (int i = 0; i < x.rows(); ++i) {
        y(i + j * x.rows()) = read(x(i, j));
      }
    }
    return y;
  }
};
 
template <typename T>
struct serializer {
  typedef T scalar_t;
 
  std::vector<T> vals_;
 
  serializer() : vals_() {}
 
  template <typename U, require_stan_scalar_t<U>* = nullptr>
  void write(const U& x) {
    vals_.push_back(x);
  }
 
  template <typename U>
  void write(const std::complex<U>& x) {
    write(x.real());
    write(x.imag());
  }
 
  template <typename U>
  void write(const std::vector<U>& x) {
    for (size_t i = 0; i < x.size(); ++i)
      write(x[i]);
  }
 
  template <typename U, require_eigen_t<U>* = nullptr>
  void write(const U& x) {
    for (int j = 0; j < x.cols(); ++j) {
      for (int i = 0; i < x.rows(); ++i) {
        write(x.coeff(i, j));
      }
    }
  }
 
  const std::vector<T>& array_vals() { return vals_; }
 
  const Eigen::Matrix<T, -1, 1>& vector_vals() { return to_vector(vals_); }
};
 
template <typename T>
deserializer<T> to_deserializer(const std::vector<T>& vals) {
  return deserializer<T>(vals);
}
 
template <typename T, require_eigen_vector_t<T>* = nullptr>
deserializer<scalar_type_t<T>> to_deserializer(const T& vals) {
  return deserializer<scalar_type_t<T>>(vals);
}
 
template <typename T>
deserializer<T> to_deserializer(const std::complex<T>& vals) {
  return to_deserializer(std::vector<T>{vals.real(), vals.imag()});
}
 
template <typename U>
void serialize_helper(serializer<U>& s) {}
 
template <typename U, typename T, typename... Ts>
void serialize_helper(serializer<U>& s, const T& x, const Ts... xs) {
  s.write(x);
  serialize_helper(s, xs...);
}
 
template <typename U, typename... Ts>
std::vector<U> serialize(const Ts... xs) {
  serializer<U> s;
  serialize_helper(s, xs...);
  return s.vals_;
}
 
template <typename T>
std::vector<real_return_t<T>> serialize_return(const T& x) {
  return serialize<real_return_t<T>>(x);
}
 
template <typename... Ts>
Eigen::VectorXd serialize_args(const Ts... xs) {
  return to_vector(serialize<double>(xs...));
}
 
}  // namespace math
}  // namespace stan
 
#endif