1#ifndef STAN_MATH_PRIM_FUN_HOLDER_HPP
2#define STAN_MATH_PRIM_FUN_HOLDER_HPP
69template <
class ArgType,
typename... Ptrs>
78template <
class ArgType,
typename... Ptrs>
83 typedef typename ArgType::Scalar
Scalar;
87 Flags = (ArgType::Flags
88 & (RowMajorBit | LvalueBit | LinearAccessBit | DirectAccessBit
89 | PacketAccessBit | NoPreferredStorageOrderBit))
91 RowsAtCompileTime = ArgType::RowsAtCompileTime,
92 ColsAtCompileTime = ArgType::ColsAtCompileTime,
93 MaxRowsAtCompileTime = ArgType::MaxRowsAtCompileTime,
94 MaxColsAtCompileTime = ArgType::MaxColsAtCompileTime,
95 InnerStrideAtCompileTime = ArgType::InnerStrideAtCompileTime,
96 OuterStrideAtCompileTime = ArgType::OuterStrideAtCompileTime
107template <
typename ArgType,
typename... Ptrs>
126template <
typename ArgType,
typename... Ptrs>
128 :
public Eigen::internal::dense_xpr_base<Holder<ArgType, Ptrs...>>::type {
130 typedef typename Eigen::internal::ref_selector<
Holder<ArgType, Ptrs...>>::type
132 typename Eigen::internal::ref_selector<ArgType>::non_const_type
m_arg;
155 template <
typename T, require_eigen_t<T>* =
nullptr>
169 m_arg = std::move(other.m_arg);
180template <
typename ArgType,
typename... Ptrs>
181struct evaluator<
stan::math::Holder<ArgType, Ptrs...>>
188 CoeffReadCost = evaluator<ArgTypeNestedCleaned>::CoeffReadCost,
191 Flags = evaluator<ArgTypeNestedCleaned>::Flags,
192 Alignment = evaluator<ArgTypeNestedCleaned>::Alignment,
201 return m_argImpl.coeff(row, col);
204 return m_argImpl.coeff(index);
208 return m_argImpl.coeffRef(row, col);
211 return m_argImpl.coeffRef(index);
214 template <
int LoadMode,
typename PacketType>
215 EIGEN_STRONG_INLINE PacketType
packet(Index row, Index col)
const {
216 return m_argImpl.template packet<LoadMode, PacketType>(row, col);
218 template <
int LoadMode,
typename PacketType>
219 EIGEN_STRONG_INLINE PacketType
packet(Index index)
const {
220 return m_argImpl.template packet<LoadMode, PacketType>(index);
223 template <
int StoreMode,
typename PacketType>
225 const PacketType& x) {
226 return m_argImpl.template writePacket<StoreMode, PacketType>(row, col, x);
228 template <
int StoreMode,
typename PacketType>
229 EIGEN_STRONG_INLINE
void writePacket(Index index,
const PacketType& x) {
230 return m_argImpl.template writePacket<StoreMode, PacketType>(index, x);
250template <
typename T,
typename... Ptrs,
251 std::enable_if_t<
sizeof...(Ptrs) >= 1>* =
nullptr>
253 return Holder<T, Ptrs...>(std::forward<T>(
arg), pointers...);
258 if constexpr (std::is_rvalue_reference<T&&>::value) {
259 return std::decay_t<T>(std::forward<T>(
arg));
261 return std::forward<T>(
arg);
279 return std::make_tuple();
282 std::enable_if_t<!(Eigen::internal::traits<std::decay_t<T>>::Flags
283 & Eigen::NestByRefBit)>* =
nullptr>
286 return std::make_tuple();
299template <
typename T, require_t<std::is_rvalue_reference<T&&>>* =
nullptr,
301 static_cast<
bool>(Eigen::
internal::traits<std::decay_t<T>>::Flags&
302 Eigen::NestByRefBit)>* =
nullptr>
304 res =
new T(std::move(a));
305 return std::make_tuple(res);
307template <
typename T, require_t<std::is_rvalue_reference<T&&>>* =
nullptr,
308 require_not_eigen_t<T>* =
nullptr>
309inline auto holder_handle_element(T&& a, T*& res) {
310 res =
new T(std::move(a));
311 return std::make_tuple(res);
325template <
typename T, std::size_t... Is,
typename... Args>
327 T&& expr, std::index_sequence<Is...>,
const std::tuple<Args*...>& ptrs) {
328 return holder(std::forward<T>(expr), std::get<Is>(ptrs)...);
340template <
typename F, std::size_t... Is,
typename... Args>
343 std::tuple<std::remove_reference_t<Args>*...> res;
344 auto ptrs = std::tuple_cat(
347 std::forward<F>(func)(*std::get<Is>(res)...),
348 std::make_index_sequence<std::tuple_size<
decltype(ptrs)>::value>(), ptrs);
366 typename F,
typename... Args,
370 std::make_index_sequence<
sizeof...(Args)>(),
371 std::forward<Args>(args)...);
384template <
typename F,
typename... Args,
387 return std::forward<F>(func)(std::forward<Args>(args)...);
Eigen::internal::ref_selector< Holder< ArgType, Ptrs... > >::type Nested
Holder< ArgType, Ptrs... > & operator=(const Holder< ArgType, Ptrs... > &other)
Eigen::Index outerStride() const
Eigen::Index rows() const
Eigen::Index innerStride() const
Holder< ArgType, Ptrs... > & operator=(Holder< ArgType, Ptrs... > &&other)
Holder(const Holder< ArgType, Ptrs... > &)=default
Holder< ArgType, Ptrs... > & operator=(const T &other)
Assignment operator assigns expresssions.
Eigen::Index cols() const
std::tuple< std::unique_ptr< Ptrs >... > m_unique_ptrs
Eigen::internal::ref_selector< ArgType >::non_const_type m_arg
Holder(Holder< ArgType, Ptrs... > &&)=default
Holder(ArgType &&arg, Ptrs *... pointers)
require_not_t< is_plain_type< std::decay_t< T > > > require_not_plain_type_t
Require type does not satisfy is_plain_type.
require_t< is_plain_type< std::decay_t< T > > > require_plain_type_t
Require type satisfies is_plain_type.
(Expert) Numerical traits for algorithmic differentiation variables.
auto make_holder_impl_construct_object(T &&expr, std::index_sequence< Is... >, const std::tuple< Args *... > &ptrs)
Second step in implementation of construction holder from a functor.
auto holder_handle_element(T &a, T *&res)
Handles single element (moving rvalue non-expressions to heap) for construction of holder or holder_c...
auto make_holder_impl(F &&func, std::index_sequence< Is... >, Args &&... args)
Implementation of construction holder from a functor.
fvar< T > arg(const std::complex< fvar< T > > &z)
Return the phase angle of the complex argument.
auto make_holder(F &&func, Args &&... args)
Constructs an expression from given arguments using given functor.
Ptrs holder(T &&arg, Ptrs *... pointers)
constexpr bool is_holder_v
The lgamma implementation in stan-math is based on either the reentrant safe lgamma_r implementation ...
evaluator< ArgTypeNestedCleaned > m_argImpl
stan::math::Holder< ArgType, Ptrs... > XprType
void writePacket(Index row, Index col, const PacketType &x)
void writePacket(Index index, const PacketType &x)
Scalar & coeffRef(Index index)
CoeffReturnType coeff(Index index) const
CoeffReturnType coeff(Index row, Index col) const
remove_all< ArgType >::type ArgTypeNestedCleaned
PacketType packet(Index index) const
PacketType packet(Index row, Index col) const
Scalar & coeffRef(Index row, Index col)
XprType::CoeffReturnType CoeffReturnType
evaluator(const XprType &xpr)
ArgType::StorageKind StorageKind
traits< ArgType >::XprKind XprKind
ArgType::StorageIndex StorageIndex