ode_adams.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_REV_FUNCTOR_ODE_ADAMS_HPP
#define STAN_MATH_REV_FUNCTOR_ODE_ADAMS_HPP
 
#include <stan/math/rev/meta.hpp>
#include <stan/math/rev/functor/cvodes_integrator.hpp>
#include <stan/math/prim/fun/Eigen.hpp>
#include <stan/math/prim/functor/apply.hpp>
#include <ostream>
#include <vector>
 
namespace stan {
namespace math {
 
template <typename F, typename T_y0, typename T_t0, typename T_ts,
          typename... T_Args, require_eigen_col_vector_t<T_y0>* = nullptr>
std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, T_Args...>,
                          Eigen::Dynamic, 1>>
ode_adams_tol_impl(const char* function_name, const F& f, const T_y0& y0,
                   const T_t0& t0, const std::vector<T_ts>& ts,
                   double relative_tolerance, double absolute_tolerance,
                   long int max_num_steps,  // NOLINT(runtime/int)
                   std::ostream* msgs, const T_Args&... args) {
  const auto& args_ref_tuple = std::make_tuple(to_ref(args)...);
  return math::apply(
      [&](const auto&... args_refs) {
        cvodes_integrator<CV_ADAMS, F, T_y0, T_t0, T_ts, ref_type_t<T_Args>...>
        integrator(function_name, f, y0, t0, ts, relative_tolerance,
                   absolute_tolerance, max_num_steps, msgs, args_refs...);
 
        return integrator();
      },
      args_ref_tuple);
}
 
template <typename F, typename T_y0, typename T_t0, typename T_ts,
          typename... T_Args, require_eigen_col_vector_t<T_y0>* = nullptr>
std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, T_Args...>,
                          Eigen::Dynamic, 1>>
ode_adams_tol(const F& f, const T_y0& y0, const T_t0& t0,
              const std::vector<T_ts>& ts, double relative_tolerance,
              double absolute_tolerance,
              long int max_num_steps,  // NOLINT(runtime/int)
              std::ostream* msgs, const T_Args&... args) {
  return ode_adams_tol_impl("ode_adams_tol", f, y0, t0, ts, relative_tolerance,
                            absolute_tolerance, max_num_steps, msgs, args...);
}
 
template <typename F, typename T_y0, typename T_t0, typename T_ts,
          typename... T_Args, require_eigen_col_vector_t<T_y0>* = nullptr>
std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, T_Args...>,
                          Eigen::Dynamic, 1>>
ode_adams(const F& f, const T_y0& y0, const T_t0& t0,
          const std::vector<T_ts>& ts, std::ostream* msgs,
          const T_Args&... args) {
  double relative_tolerance = 1e-10;
  double absolute_tolerance = 1e-10;
  long int max_num_steps = 1e8;  // NOLINT(runtime/int)
 
  return ode_adams_tol_impl("ode_adams", f, y0, t0, ts, relative_tolerance,
                            absolute_tolerance, max_num_steps, msgs, args...);
}
 
}  // namespace math
}  // namespace stan
#endif