operands_and_partials.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_FUNCTOR_OPERANDS_AND_PARTIALS_HPP
#define STAN_MATH_PRIM_FUNCTOR_OPERANDS_AND_PARTIALS_HPP
 
#include <stan/math/prim/fun/Eigen.hpp>
#include <stan/math/prim/meta/require_generics.hpp>
#include <stan/math/prim/meta/return_type.hpp>
#include <stan/math/prim/functor/broadcast_array.hpp>
#include <vector>
#include <type_traits>
#include <tuple>
 
namespace stan {
namespace math {
 
template <typename Op1 = double, typename Op2 = double, typename Op3 = double,
          typename Op4 = double, typename Op5 = double, typename Op6 = double,
          typename Op7 = double, typename Op8 = double,
          typename T_return_type
          = return_type_t<Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8>>
class operands_and_partials;  // Forward declaration
 
namespace internal {
 
template <typename ViewElt, typename Op, typename Enable = void>
class ops_partials_edge;
 
template <typename ViewElt, typename Op>
struct ops_partials_edge<ViewElt, Op, require_st_arithmetic<Op>> {
  using inner_op = std::conditional_t<is_eigen<value_type_t<Op>>::value,
                                      value_type_t<Op>, Op>;
  using partials_t = empty_broadcast_array<ViewElt, inner_op>;
  partials_t partials_;
  empty_broadcast_array<partials_t, inner_op> partials_vec_;
  static constexpr double operands_{0};
  ops_partials_edge() = default;
 
  template <typename T,
            require_not_same_t<
                std::decay_t<T>,
                std::decay_t<ops_partials_edge<
                    ViewElt, Op, require_st_arithmetic<Op>>>>* = nullptr>
  constexpr explicit ops_partials_edge(T&& /* op */) noexcept {}
 
  static constexpr double operand() noexcept {
    return static_cast<double>(0.0);
  }
 
  static constexpr double partial() noexcept {
    return static_cast<double>(0.0);
  }
  static constexpr double dx() noexcept { return static_cast<double>(0); }
  static constexpr int size() noexcept { return 0; }  // reverse mode
};
 
template <typename ViewElt, typename Op>
constexpr double
    ops_partials_edge<ViewElt, Op, require_st_arithmetic<Op>>::operands_;
 
}  // namespace internal
 
template <typename Op1, typename Op2, typename Op3, typename Op4, typename Op5,
          typename Op6, typename Op7, typename Op8, typename T_return_type>
class operands_and_partials {
 public:
  explicit operands_and_partials(const Op1& /* op1 */) noexcept {}
  operands_and_partials(const Op1& /* op1 */, const Op2& /* op2 */) noexcept {}
  operands_and_partials(const Op1& /* op1 */, const Op2& /* op2 */,
                        const Op3& /* op3 */) noexcept {}
  operands_and_partials(const Op1& /* op1 */, const Op2& /* op2 */,
                        const Op3& /* op3 */, const Op4& /* op4 */) noexcept {}
  operands_and_partials(const Op1& /* op1 */, const Op2& /* op2 */,
                        const Op3& /* op3 */, const Op4& /* op4 */,
                        const Op5& /* op5 */) noexcept {}
  operands_and_partials(const Op1& /* op1 */, const Op2& /* op2 */,
                        const Op3& /* op3 */, const Op4& /* op4 */,
                        const Op5& /* op5 */, const Op6& /* op6 */) noexcept {}
  operands_and_partials(const Op1& /* op1 */, const Op2& /* op2 */,
                        const Op3& /* op3 */, const Op4& /* op4 */,
                        const Op5& /* op5 */, const Op6& /* op6 */,
                        const Op7& /* op7 */) noexcept {}
  operands_and_partials(const Op1& /* op1 */, const Op2& /* op2 */,
                        const Op3& /* op3 */, const Op4& /* op4 */,
                        const Op5& /* op5 */, const Op6& /* op6 */,
                        const Op7& /* op7 */, const Op8& /* op8 */) noexcept {}
 
  inline double build(double value) const noexcept { return value; }
 
  // These will always be 0 size base template instantiations (above).
  internal::ops_partials_edge<double, std::decay_t<Op1>> edge1_;
  internal::ops_partials_edge<double, std::decay_t<Op2>> edge2_;
  internal::ops_partials_edge<double, std::decay_t<Op3>> edge3_;
  internal::ops_partials_edge<double, std::decay_t<Op4>> edge4_;
  internal::ops_partials_edge<double, std::decay_t<Op5>> edge5_;
  internal::ops_partials_edge<double, std::decay_t<Op6>> edge6_;
  internal::ops_partials_edge<double, std::decay_t<Op7>> edge7_;
  internal::ops_partials_edge<double, std::decay_t<Op8>> edge8_;
};
 
}  // namespace math
}  // namespace stan
#endif