accumulate_adjoints.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_REV_CORE_ACCUMULATE_ADJOINTS_HPP
#define STAN_MATH_REV_CORE_ACCUMULATE_ADJOINTS_HPP
 
#include <stan/math/prim/functor/apply.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... Pargs>
inline double* accumulate_adjoints(double* dest, const var& x, Pargs&&... args);
 
template <typename VarVec, require_std_vector_vt<is_var, VarVec>* = nullptr,
          typename... Pargs>
inline double* accumulate_adjoints(double* dest, VarVec&& x, Pargs&&... args);
 
template <typename VecContainer,
          require_std_vector_st<is_var, VecContainer>* = nullptr,
          require_std_vector_vt<is_container, VecContainer>* = nullptr,
          typename... Pargs>
inline double* accumulate_adjoints(double* dest, VecContainer&& x,
                                   Pargs&&... args);
 
template <typename EigT, require_eigen_vt<is_var, EigT>* = nullptr,
          typename... Pargs>
inline double* accumulate_adjoints(double* dest, EigT&& x, Pargs&&... args);
 
template <typename Arith, require_st_arithmetic<Arith>* = nullptr,
          typename... Pargs>
inline double* accumulate_adjoints(double* dest, Arith&& x, Pargs&&... args);
 
template <typename Tuple, require_tuple_t<Tuple>* = nullptr, typename... Pargs>
inline double* accumulate_adjoints(double* dest, Tuple&& x, Pargs&&... args);
 
inline double* accumulate_adjoints(double* dest);
 
template <typename... Pargs>
inline double* accumulate_adjoints(double* dest, const var& x,
                                   Pargs&&... args) {
  *dest += x.adj();
  return accumulate_adjoints(dest + 1, std::forward<Pargs>(args)...);
}
 
template <typename VarVec, require_std_vector_vt<is_var, VarVec>*,
          typename... Pargs>
inline double* accumulate_adjoints(double* dest, VarVec&& x, Pargs&&... args) {
  for (auto&& x_iter : x) {
    *dest += x_iter.adj();
    ++dest;
  }
  return accumulate_adjoints(dest, std::forward<Pargs>(args)...);
}
 
template <typename VecContainer, require_std_vector_st<is_var, VecContainer>*,
          require_std_vector_vt<is_container, VecContainer>*, typename... Pargs>
inline double* accumulate_adjoints(double* dest, VecContainer&& x,
                                   Pargs&&... args) {
  for (auto&& x_iter : x) {
    dest = accumulate_adjoints(dest, x_iter);
  }
  return accumulate_adjoints(dest, std::forward<Pargs>(args)...);
}
 
template <typename EigT, require_eigen_vt<is_var, EigT>*, typename... Pargs>
inline double* accumulate_adjoints(double* dest, EigT&& x, Pargs&&... args) {
  Eigen::Map<Eigen::MatrixXd>(dest, x.rows(), x.cols()) += x.adj();
  return accumulate_adjoints(dest + x.size(), std::forward<Pargs>(args)...);
}
 
template <typename Arith, require_st_arithmetic<Arith>*, typename... Pargs>
inline double* accumulate_adjoints(double* dest, Arith&& x, Pargs&&... args) {
  return accumulate_adjoints(dest, std::forward<Pargs>(args)...);
}
 
template <typename Tuple, require_tuple_t<Tuple>*, typename... Pargs>
inline double* accumulate_adjoints(double* dest, Tuple&& x, Pargs&&... args) {
  dest = stan::math::apply(
      [dest](auto&&... tuple_args) {
        return accumulate_adjoints(dest, tuple_args...);
      },
      std::forward<Tuple>(x));
  return accumulate_adjoints(dest, std::forward<Pargs>(args)...);
}
 
inline double* accumulate_adjoints(double* dest) { return dest; }
 
}  // namespace math
}  // namespace stan
 
#endif