ode_ckrk.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_FUNCTOR_ODE_CKRK_HPP
#define STAN_MATH_PRIM_FUNCTOR_ODE_CKRK_HPP
 
#include <stan/math/prim/meta.hpp>
#include <stan/math/prim/functor/apply.hpp>
#include <stan/math/prim/functor/arkode_integrator.hpp>
#include <stan/math/prim/fun/Eigen.hpp>
#include <ostream>
#include <tuple>
#include <vector>
 
namespace stan {
namespace math {
 
template <typename F, typename T_y0, typename T_t0, typename T_ts,
          typename... Args, require_eigen_vector_t<T_y0>* = nullptr>
inline std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, Args...>,
                                 Eigen::Dynamic, 1>>
ode_ckrk_tol_impl(const char* function_name, const F& f, const T_y0& y0_arg,
                  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 Args&... args) {
  const auto& args_ref_tuple = std::make_tuple(to_ref(args)...);
  return math::apply(
      [&](const auto&... args_refs) {
        arkode_integrator<ARKODE_CASH_KARP_6_4_5, false, F, T_y0, T_t0, T_ts,
                          ref_type_t<Args>...>
        integrator(function_name, f, y0_arg, 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... Args, require_eigen_vector_t<T_y0>* = nullptr>
inline std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, Args...>,
                                 Eigen::Dynamic, 1>>
ode_ckrk_tol(const F& f, const T_y0& y0_arg, 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 Args&... args) {
  return ode_ckrk_tol_impl("ode_ckrk_tol", f, y0_arg, t0, ts,
                           relative_tolerance, absolute_tolerance,
                           max_num_steps, msgs, args...);
}
 
template <typename F, typename T_y0, typename T_t0, typename T_ts,
          typename... Args, require_eigen_vector_t<T_y0>* = nullptr>
inline std::vector<Eigen::Matrix<stan::return_type_t<T_y0, T_t0, T_ts, Args...>,
                                 Eigen::Dynamic, 1>>
ode_ckrk(const F& f, const T_y0& y0, T_t0 t0, const std::vector<T_ts>& ts,
         std::ostream* msgs, const Args&... args) {
  double relative_tolerance = 1e-6;
  double absolute_tolerance = 1e-6;
  long int max_num_steps = 1e6;  // NOLINT(runtime/int)
 
  return ode_ckrk_tol_impl("ode_ckrk", f, y0, t0, ts, relative_tolerance,
                           absolute_tolerance, max_num_steps, msgs, args...);
}
 
}  // namespace math
}  // namespace stan
#endif