finite_diff.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_FWD_FUNCTOR_FINITE_DIFF_HPP
#define STAN_MATH_FWD_FUNCTOR_FINITE_DIFF_HPP
 
#include <stan/math/prim/meta.hpp>
#include <stan/math/prim/functor/apply_scalar_binary.hpp>
#include <stan/math/prim/functor/finite_diff_gradient_auto.hpp>
#include <stan/math/prim/fun/value_of.hpp>
#include <stan/math/prim/fun/sum.hpp>
#include <stan/math/prim/fun/serializer.hpp>
 
namespace stan {
namespace math {
namespace internal {
template <typename FuncTangent, typename InputArg,
          require_not_st_fvar<InputArg>* = nullptr>
inline constexpr double aggregate_tangent(const FuncTangent& tangent,
                                          const InputArg& arg) {
  return 0;
}
 
template <typename FuncTangent, typename InputArg,
          require_st_fvar<InputArg>* = nullptr>
inline auto aggregate_tangent(const FuncTangent& tangent, const InputArg& arg) {
  return sum(apply_scalar_binary(
      tangent, arg, [](const auto& x, const auto& y) { return x * y.d_; }));
}
}  // namespace internal
 
template <typename F, typename... TArgs,
          require_any_st_fvar<TArgs...>* = nullptr>
inline auto finite_diff(const F& func, const TArgs&... args) {
  using FvarT = return_type_t<TArgs...>;
  using FvarInnerT = typename FvarT::Scalar;
 
  std::vector<FvarInnerT> serialised_args
      = serialize<FvarInnerT>(value_of(args)...);
 
  auto serial_functor = [&](const auto& v) {
    auto v_deserializer = to_deserializer(v);
    return func(v_deserializer.read(args)...);
  };
 
  FvarInnerT rtn_value;
  std::vector<FvarInnerT> grad;
  finite_diff_gradient_auto(serial_functor, serialised_args, rtn_value, grad);
 
  FvarInnerT rtn_grad = 0;
  auto grad_deserializer = to_deserializer(grad);
  // Use a fold-expression to aggregate tangents for input arguments
  static_cast<void>(
      std::initializer_list<int>{(rtn_grad += internal::aggregate_tangent(
                                      grad_deserializer.read(args), args),
                                  0)...});
 
  return FvarT(rtn_value, rtn_grad);
}
 
template <typename F, typename... TArgs,
          require_all_not_st_fvar<TArgs...>* = nullptr>
inline auto finite_diff(const F& func, const TArgs&... args) {
  return func(args...);
}
 
}  // namespace math
}  // namespace stan
 
#endif