to_arena.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_REV_FUN_TO_ARENA_HPP
#define STAN_MATH_REV_FUN_TO_ARENA_HPP
 
#include <stan/math/prim/fun/Eigen.hpp>
#include <stan/math/rev/meta.hpp>
#include <stan/math/rev/core/arena_matrix.hpp>
#include <stan/math/prim/functor.hpp>
#include <vector>
#include <cstring>
 
namespace stan {
namespace math {
 
template <typename T, require_not_same_t<T, arena_t<T>>* = nullptr,
          require_not_container_t<T>* = nullptr,
          require_not_matrix_cl_t<T>* = nullptr>
inline arena_t<T> to_arena(T&& a) {
  return std::forward<T>(a);
}
 
template <typename T, require_same_t<T, arena_t<T>>* = nullptr,
          require_not_matrix_cl_t<T>* = nullptr,
          require_not_std_vector_t<T>* = nullptr,
          require_not_tuple_t<T>* = nullptr>
inline std::remove_reference_t<T> to_arena(T&& a) {
  // intentionally never returning a reference. If an object is just
  // referenced it will likely go out of scope before it is used.
  return std::forward<T>(a);
}
 
template <typename T, require_eigen_t<T>* = nullptr,
          require_not_same_t<T, arena_t<T>>* = nullptr>
inline arena_t<T> to_arena(const T& a) {
  return arena_t<T>(a);
}
 
template <typename T>
inline std::vector<T, arena_allocator<T>> to_arena(
    const std::vector<T, arena_allocator<T>>& a) {
  // What we want to do here is the same as moving input into output, except
  // that we want input to be left unchanged. With any normal allocator that
  // lead to deallocating memory twice (probably segfaulting). However,
  // dealocation with `arena_allocator` is a no-op, so we can do that.
  std::vector<T, arena_allocator<T>> res;
  std::memcpy(static_cast<void*>(&res), static_cast<const void*>(&a),
              sizeof(std::vector<T, arena_allocator<T>>));
  return res;
}
 
template <typename T, require_same_t<T, arena_t<T>>* = nullptr>
inline arena_t<std::vector<T>> to_arena(const std::vector<T>& a) {
  return {a.begin(), a.end()};
}
 
template <typename T, require_not_same_t<T, arena_t<T>>* = nullptr>
inline arena_t<std::vector<T>> to_arena(const std::vector<T>& a) {
  arena_t<std::vector<T>> res;
  res.reserve(a.size());
  for (const T& i : a) {
    res.push_back(to_arena(i));
  }
  return res;
}
 
template <typename Tuple, require_tuple_t<Tuple>* = nullptr>
inline auto to_arena(Tuple&& tup) {
  return stan::math::apply(
      [](auto&&... args) {
        return std::make_tuple(to_arena(std::forward<decltype(args)>(args))...);
      },
      std::forward<Tuple>(tup));
}
 
template <bool Condition, typename T, std::enable_if_t<!Condition>* = nullptr>
inline T to_arena_if(T&& a) {
  return std::forward<T>(a);
}
 
template <bool Condition, typename T, std::enable_if_t<Condition>* = nullptr>
inline arena_t<T> to_arena_if(const T& a) {
  return to_arena(a);
}
 
}  // namespace math
}  // namespace stan
 
#endif