partials_propagator.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_FUNCTOR_PARTIALS_PROPOGATOR_HPP
#define STAN_MATH_PRIM_FUNCTOR_PARTIALS_PROPOGATOR_HPP
 
#include <stan/math/prim/fun/Eigen.hpp>
#include <stan/math/prim/meta/require_generics.hpp>
#include <stan/math/prim/meta/return_type.hpp>
#include <stan/math/prim/functor/broadcast_array.hpp>
#include <stan/math/prim/functor/operands_and_partials.hpp>
#include <vector>
#include <type_traits>
#include <tuple>
 
namespace stan {
namespace math {
 
namespace internal {
 
template <typename ReturnType, typename Enable, typename... Ops>
class partials_propagator;
 
template <typename ReturnType, typename... Ops>
class partials_propagator<ReturnType, require_arithmetic_t<ReturnType>,
                          Ops...> {
 public:
  template <typename... Types>
  explicit partials_propagator(Types&&... /* ops */) noexcept {}
 
  inline static double build(double value) noexcept { return value; }
  std::tuple<internal::ops_partials_edge<double, std::decay_t<Ops>>...> edges_;
};
 
}  // namespace internal
 
template <std::size_t I, class... Types>
inline constexpr auto& edge(
    internal::partials_propagator<Types...>& x) noexcept {
  return std::get<I>(x.edges_);
};
 
template <std::size_t I, class... Types>
inline constexpr auto& partials(
    internal::partials_propagator<Types...>& x) noexcept {
  return std::get<I>(x.edges_).partials_;
};
 
template <std::size_t I, class... Types>
inline constexpr auto& partials_vec(
    internal::partials_propagator<Types...>& x) noexcept {
  return std::get<I>(x.edges_).partials_vec_;
};
 
template <typename... Ops>
inline auto make_partials_propagator(Ops&&... ops) {
  using return_type = return_type_t<Ops...>;
  return internal::partials_propagator<return_type, void,
                                       plain_type_t<std::decay_t<Ops>>...>(
      std::forward<Ops>(ops)...);
}
 
}  // namespace math
}  // namespace stan
#endif