apply_scalar_unary.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_FUNCTOR_APPLY_SCALAR_UNARY_HPP
#define STAN_MATH_PRIM_FUNCTOR_APPLY_SCALAR_UNARY_HPP
 
#include <stan/math/prim/fun/Eigen.hpp>
#include <stan/math/prim/meta/is_eigen.hpp>
#include <stan/math/prim/meta/is_complex.hpp>
#include <stan/math/prim/meta/holder.hpp>
#include <stan/math/prim/meta/require_generics.hpp>
#include <stan/math/prim/meta/is_vector.hpp>
#include <stan/math/prim/meta/is_vector_like.hpp>
#include <stan/math/prim/meta/plain_type.hpp>
#include <utility>
#include <vector>
 
namespace stan {
namespace math {
 
template <typename F, typename T, typename Enable = void>
struct apply_scalar_unary;
 
template <typename F, typename T>
struct apply_scalar_unary<F, T, require_eigen_t<T>> {
  template <typename TT>
  static inline auto apply(TT&& x) {
    return make_holder(
        [](auto&& xx) {
          return std::forward<decltype(xx)>(xx).unaryExpr([](auto&& xxx) {
            return apply_scalar_unary<F, decltype(xxx)>::apply(
                std::forward<decltype(xxx)>(xxx));
          });
        },
        std::forward<TT>(x));
  }
 
  using return_t = std::decay_t<decltype(
      apply_scalar_unary<F, T>::apply(std::declval<T>()))>;
};
 
template <typename F, typename T>
struct apply_scalar_unary<F, T, require_floating_point_t<T>> {
  using return_t
      = std::decay_t<decltype(F::fun(std::declval<std::decay_t<T>>()))>;
 
  template <typename T2>
  static inline auto apply(T2 x) {
    return F::fun(x);
  }
};
 
template <typename F, typename T>
struct apply_scalar_unary<F, T, require_complex_t<T>> {
  template <typename T2>
  static inline auto apply(T2&& x) {
    return F::fun(std::forward<T2>(x));
  }
  using return_t
      = std::decay_t<decltype(F::fun(std::declval<std::decay_t<T>>()))>;
};
 
template <typename F, typename T>
struct apply_scalar_unary<F, T, require_integral_t<T>> {
  template <typename T2>
  static inline auto apply(T2 x) {
    return F::fun(x);
  }
  using return_t = std::decay_t<decltype(F::fun(std::declval<double>()))>;
};
 
template <typename F, typename T>
struct apply_scalar_unary<F, T, require_std_vector_t<T>> {
  using return_t = typename std::vector<plain_type_t<
      typename apply_scalar_unary<F, value_type_t<std::decay_t<T>>>::return_t>>;
 
  template <typename TT>
  static inline auto apply(TT&& x) {
    return_t fx(x.size());
    for (size_t i = 0; i < x.size(); ++i) {
      if constexpr (std::is_rvalue_reference_v<TT&&>) {
        fx[i] = apply_scalar_unary<F, value_type_t<TT>>::apply(std::move(x[i]));
      } else {
        fx[i] = apply_scalar_unary<F, value_type_t<TT>>::apply(x[i]);
      }
    }
    return fx;
  }
};
 
}  // namespace math
}  // namespace stan
#endif