return_type.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_PRIM_META_RETURN_TYPE_HPP
#define STAN_MATH_PRIM_META_RETURN_TYPE_HPP
 
#include <stan/math/prim/fun/Eigen.hpp>
#include <stan/math/prim/meta/promote_args.hpp>
#include <stan/math/prim/meta/base_type.hpp>
#include <stan/math/prim/meta/scalar_type.hpp>
#include <complex>
#include <vector>
 
namespace stan {
 
template <typename... Ts>
struct real_return {
  using type = double;
};
 
template <typename T, typename... Ts>
struct real_return<T, Ts...> {
  using type
      = promote_args_t<base_type_t<T>, typename real_return<Ts...>::type>;
};
 
template <typename... Ts>
using real_return_t = typename real_return<Ts...>::type;
 
template <typename... Ts>
using complex_return_t = std::complex<real_return_t<Ts...>>;
 
template <typename... Ts>
using std_vector_return_t = std::vector<real_return_t<Ts...>>;
 
template <typename... Ts>
using matrix_return_t = Eigen::Matrix<real_return_t<Ts...>, -1, -1>;
 
template <typename... Ts>
using vector_return_t = Eigen::Matrix<real_return_t<Ts...>, -1, 1>;
 
template <typename... Ts>
using row_vector_return_t = Eigen::Matrix<real_return_t<Ts...>, 1, -1>;
 
template <typename T1, typename T2>
struct scalar_lub {
  using type = promote_args_t<T1, T2>;
};
 
template <typename T1, typename T2>
struct scalar_lub<std::complex<T1>, T2> {
  using type = std::complex<promote_args_t<T1, T2>>;
};
 
template <typename T1, typename T2>
struct scalar_lub<T1, std::complex<T2>> {
  using type = std::complex<promote_args_t<T1, T2>>;
};
 
template <typename T1, typename T2>
struct scalar_lub<std::complex<T1>, std::complex<T2>> {
  using type = std::complex<promote_args_t<T1, T2>>;
};
 
template <typename T1, typename T2>
using scalar_lub_t = typename scalar_lub<T1, T2>::type;
 
namespace internal {
template <typename... Ts>
struct return_type_impl {
  using type = double;
};
 
template <typename T, typename... Ts>
struct return_type_impl<T, Ts...> {
  using type
      = scalar_lub_t<scalar_type_t<T>, typename return_type_impl<Ts...>::type>;
};
 
template <typename... T, typename... Ts>
struct return_type_impl<std::tuple<T...>, Ts...> {
  using type = scalar_lub_t<typename return_type_impl<T...>::type,
                            typename return_type_impl<Ts...>::type>;
};
 
}  // namespace internal
 
template <typename... Ts>
struct return_type : internal::return_type_impl<std::decay_t<Ts>...> {};
 
template <typename... Ts>
using return_type_t = typename return_type<Ts...>::type;
 
template <template <class...> class Check, typename... Ts>
using require_return_type_t = require_t<Check<return_type_t<Ts...>>>;
 
template <template <class...> class Check, typename... Ts>
using require_not_return_type_t = require_not_t<Check<return_type_t<Ts...>>>;
 
}  // namespace stan
#endif