callback_vari.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_REV_CORE_CALLBACK_VARI_HPP
#define STAN_MATH_REV_CORE_CALLBACK_VARI_HPP
 
#include <stan/math/rev/core/vari.hpp>
#include <new>
#include <utility>
 
namespace stan {
namespace math {
namespace internal {
 
template <typename T, typename F>
struct callback_vari : public vari_value<T> {
  F rev_functor_;
 
  template <typename S,
            require_same_t<plain_type_t<T>, plain_type_t<S>>* = nullptr>
  explicit callback_vari(S&& value, F&& rev_functor)
      : vari_value<T>(std::move(value), true),
        rev_functor_(std::forward<F>(rev_functor)) {}
 
  inline void chain() final { rev_functor_(*this); }
};
 
}  // namespace internal
 
template <typename T, typename F>
inline internal::callback_vari<plain_type_t<T>, F>* make_callback_vari(
    T&& value, F&& functor) {
  // Captures such as fixed-size Eigen matrices can need more than the 8 byte
  // alignment of `vari_base::operator new`.
  using vari_t = internal::callback_vari<plain_type_t<T>, F>;
  return ::new (ChainableStack::instance_->memalloc_.alloc(sizeof(vari_t),
                                                           alignof(vari_t)))
      vari_t(std::move(value), std::forward<F>(functor));
}
 
template <typename T, typename F>
inline var_value<plain_type_t<T>> make_callback_var(T&& value, F&& functor) {
  return var_value<plain_type_t<T>>(
      make_callback_vari(std::move(value), std::forward<F>(functor)));
}
 
}  // namespace math
}  // namespace stan
 
#endif