deep_copy_vars.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_REV_CORE_DEEP_COPY_VARS_HPP
#define STAN_MATH_REV_CORE_DEEP_COPY_VARS_HPP
 
#include <stan/math/prim/functor/apply.hpp>
#include <stan/math/prim/functor/make_holder_tuple.hpp>
#include <stan/math/prim/meta.hpp>
#include <stan/math/rev/meta.hpp>
#include <stan/math/rev/core/var.hpp>
 
#include <utility>
#include <vector>
 
namespace stan {
namespace math {
 
template <typename Arith, typename = require_arithmetic_t<scalar_type_t<Arith>>>
inline Arith deep_copy_vars(Arith&& arg) {
  return std::forward<Arith>(arg);
}
 
inline auto deep_copy_vars(const var& arg) {
  return var(new vari(arg.val(), false));
}
 
template <typename VarVec, require_std_vector_vt<is_var, VarVec>* = nullptr>
inline auto deep_copy_vars(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 VecContainer,
          require_std_vector_st<is_var, VecContainer>* = nullptr,
          require_std_vector_vt<is_container, VecContainer>* = nullptr>
inline auto deep_copy_vars(VecContainer&& arg) {
  std::vector<value_type_t<VecContainer>> copy_vec(arg.size());
  for (size_t i = 0; i < arg.size(); ++i) {
    copy_vec[i] = deep_copy_vars(arg[i]);
  }
  return copy_vec;
}
 
template <typename EigT, require_eigen_vt<is_var, EigT>* = nullptr>
inline auto deep_copy_vars(EigT&& arg) {
  return arg.unaryExpr([](auto&& x) { return var(new vari(x.val(), false)); })
      .eval();
}
 
template <typename Tuple, require_tuple_t<Tuple>* = nullptr>
inline auto deep_copy_vars(Tuple&& arg) {
  return stan::math::apply(
      [](auto&&... tuple_args) {
        return make_holder_tuple(
            deep_copy_vars(std::forward<decltype(tuple_args)>(tuple_args))...);
      },
      std::forward<Tuple>(arg));
}
 
}  // namespace math
}  // namespace stan
 
#endif