fma.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_FWD_FUN_FMA_HPP
#define STAN_MATH_FWD_FUN_FMA_HPP
 
#include <stan/math/fwd/meta.hpp>
#include <stan/math/fwd/core.hpp>
#include <stan/math/prim/fun/fma.hpp>
 
namespace stan {
namespace math {
 
template <typename T1, typename T2, typename T3,
          require_all_stan_scalar_t<T1, T2, T3>* = nullptr>
inline fvar<return_type_t<T1, T2, T3>> fma(const fvar<T1>& x1,
                                           const fvar<T2>& x2,
                                           const fvar<T3>& x3) {
  return fvar<return_type_t<T1, T2, T3>>(
      fma(x1.val_, x2.val_, x3.val_),
      x1.d_ * x2.val_ + x2.d_ * x1.val_ + x3.d_);
}
 
template <typename T1, typename T2, typename T3,
          require_all_stan_scalar_t<T1, T2, T3>* = nullptr>
inline fvar<return_type_t<T1, T2, T3>> fma(const T1& x1, const fvar<T2>& x2,
                                           const fvar<T3>& x3) {
  return fvar<return_type_t<T1, T2, T3>>(fma(x1, x2.val_, x3.val_),
                                         x2.d_ * x1 + x3.d_);
}
 
template <typename T1, typename T2, typename T3,
          require_all_stan_scalar_t<T1, T2, T3>* = nullptr>
inline fvar<return_type_t<T1, T2, T3>> fma(const fvar<T1>& x1, const T2& x2,
                                           const fvar<T3>& x3) {
  return fvar<return_type_t<T1, T2, T3>>(fma(x1.val_, x2, x3.val_),
                                         x1.d_ * x2 + x3.d_);
}
 
template <typename T1, typename T2, typename T3,
          require_all_stan_scalar_t<T1, T2, T3>* = nullptr>
inline fvar<return_type_t<T1, T2, T3>> fma(const fvar<T1>& x1,
                                           const fvar<T2>& x2, const T3& x3) {
  return fvar<return_type_t<T1, T2, T3>>(fma(x1.val_, x2.val_, x3),
                                         x1.d_ * x2.val_ + x2.d_ * x1.val_);
}
 
template <typename T1, typename T2, typename T3,
          require_all_stan_scalar_t<T1, T2, T3>* = nullptr>
inline fvar<return_type_t<T1, T2, T3>> fma(const T1& x1, const T2& x2,
                                           const fvar<T3>& x3) {
  return fvar<return_type_t<T1, T2, T3>>(fma(x1, x2, x3.val_), x3.d_);
}
 
template <typename T1, typename T2, typename T3,
          require_all_stan_scalar_t<T1, T2, T3>* = nullptr>
inline fvar<return_type_t<T1, T2, T3>> fma(const fvar<T1>& x1, const T2& x2,
                                           const T3& x3) {
  return fvar<return_type_t<T1, T2, T3>>(fma(x1.val_, x2, x3), x1.d_ * x2);
}
 
template <typename T1, typename T2, typename T3,
          require_all_stan_scalar_t<T1, T2, T3>* = nullptr>
inline fvar<return_type_t<T1, T2, T3>> fma(const T1& x1, const fvar<T2>& x2,
                                           const T3& x3) {
  return fvar<return_type_t<T1, T2, T3>>(fma(x1, x2.val_, x3), x2.d_ * x1);
}
 
}  // namespace math
}  // namespace stan
#endif