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/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>> {
  static inline auto apply(const std::decay_t<T>& x) {
    return x.unaryExpr([](auto&& x) {
      return apply_scalar_unary<F, std::decay_t<decltype(x)>>::apply(x);
    });
  }
 
  using return_t = std::decay_t<decltype(
      apply_scalar_unary<F, std::decay_t<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>>()))>;
 
  static inline auto apply(T x) { return F::fun(x); }
};
 
template <typename F, typename T>
struct apply_scalar_unary<F, T, require_complex_t<T>> {
  static inline auto apply(const std::decay_t<T>& x) { return F::fun(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>> {
  static inline auto apply(T 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>>;
 
  static inline auto apply(const std::decay_t<T>& x) {
    return_t fx(x.size());
    for (size_t i = 0; i < x.size(); ++i) {
      fx[i] = apply_scalar_unary<F, value_type_t<T>>::apply(x[i]);
    }
    return fx;
  }
};
 
}  // namespace math
}  // namespace stan
#endif