return_type.hpp File Reference

#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>

Go to the source code of this file.

Classes
struct	stan::real_return< Ts >
	Provides a member type alias named type, the value of which is the least type under Stan's assignability relation that can be assigned a double and all of the base types of the specified arguments after removing qualifiers (const and volatile) and decaying (lvalue to rvalue by removing references) and array to pointer). More...
struct	stan::real_return< T, Ts... >
struct	stan::scalar_lub< T1, T2 >
	Defines a member type named type that is the least scalar type to which both template parameter scalar types are assignable in Stan. More...
struct	stan::scalar_lub< std::complex< T1 >, T2 >
struct	stan::scalar_lub< T1, std::complex< T2 > >
struct	stan::scalar_lub< std::complex< T1 >, std::complex< T2 > >
struct	stan::internal::return_type_impl< Ts >
struct	stan::internal::return_type_impl< T, Ts... >
struct	stan::internal::return_type_impl< std::tuple< T... >, Ts... >
struct	stan::return_type< Ts >
	Template metaprogram to calculate the base scalar return type resulting from promoting all the scalar types of the template parameters to the least type to which all the base types of the arguments are assignable. More...

Namespaces
namespace	stan
	The lgamma implementation in stan-math is based on either the reentrant safe lgamma_r implementation from C or the boost::math::lgamma implementation.
namespace	stan::internal

Typedefs
template<typename... Ts>
using	stan::real_return_t = typename real_return< Ts... >::type
	Convenience type to calculate the real return type.
template<typename... Ts>
using	stan::complex_return_t = std::complex< real_return_t< Ts... > >
	Convenience type to calculate the complex return type, which wraps std::complex around the return type of the specified template parameters.
template<typename... Ts>
using	stan::std_vector_return_t = std::vector< real_return_t< Ts... > >
	Convenience type to calculate the complex return type, which wraps std::vector around the return type of the specified template parameters.
template<typename... Ts>
using	stan::matrix_return_t = Eigen::Matrix< real_return_t< Ts... >, -1, -1 >
	Convenience type to calculate the complex return type, which wraps Eigen::Matrix< , -1, -1> around the return type of the specified template parameters.
template<typename... Ts>
using	stan::vector_return_t = Eigen::Matrix< real_return_t< Ts... >, -1, 1 >
	Convenience type to calculate the complex return type, which wraps Eigen::Matrix< , -1, 1> around the return type of the specified template parameters.
template<typename... Ts>
using	stan::row_vector_return_t = Eigen::Matrix< real_return_t< Ts... >, 1, -1 >
	Convenience type to calculate the complex return type, which wraps Eigen::Matrix< , 1, -1> around the return type of the specified template parameters.
template<typename T1 , typename T2 >
using	stan::scalar_lub_t = typename scalar_lub< T1, T2 >::type
	Convenience type for the least upper bound of the specified template parameters in Stan's assignment ordering.
template<typename... Ts>
using	stan::return_type_t = typename return_type< Ts... >::type
	Convenience type for the return type of the specified template parameters.
template<template< class... > class Check, typename... Ts>
using	stan::require_return_type_t = require_t< Check< return_type_t< Ts... > > >
template<template< class... > class Check, typename... Ts>
using	stan::require_not_return_type_t = require_not_t< Check< return_type_t< Ts... > > >