stan Namespace Reference

Detailed Description

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

Operations in Eigen Expressions hold their arguments either by value or by reference.

The reentrant safe lgamma_r implementation is preferred as it is faster when compared to the boost version. However, the reentrant safe lgamma_r C function is not available with MinGW compilers used on Windows. Therefore, the boost version is used on Windows with MinGW compilers as fall back. For details on the speed evaluations, please refer to https://github.com/stan-dev/math/pull/1255 .

Which one is chosen depends on type of the argument. Other operations are held by value. "Heavy" objects that can hold data themselves, such as Eigen::Matrix or Eigen::Ref are instead held by reference. THis is the only criterion - holding rvalue arguments by value is not supported, so we can not use perfect forwarding.

When returning an expression from function we have to be careful that any arguments in this expression that are held by reference do not go out of scope. For instance, consider the function:

template<typename T>
auto f(const T& x){
  const Eigen::Ref<const Eigen::VectorXd>& x_ref = x;
  return x_ref.cwiseProduct(x_ref);
}

And the code calling it:

Eigen::MatrixXd test_mat(2,2);
test_mat << 5, 5, 5, 5;
VectorXd X  = f(test_mat.diagonal());

This function will return back a CwiseBinaryOp Eigen expression, which is then evaluated out of the function scope when assigned to X. The expression references x_ref, which was created withing function and destroyed when the function returned. The returned expression is evaluated after the function returned, so its evaluation references a matrix that was already deleted. In other words the returned expression contains a dangling reference.

So a function returning an expression referencing local matrices or matrices that were rvalue reference arguments to the function will not work.

A workarount to this issue is allocating and constructing or moving such objects to heap. Holder object is a no-op operation that can also take pointers to such objects and release them when it goes out of scope. It can be created either by directly supplying pointers to such objects to holder function or by forwarding function arguments and moving local variables to make_holder, which will move any rvalues to heap first.

Namespaces
namespace	internal
namespace	math
	Matrices and templated mathematical functions.

Classes
struct	base_type
	Metaprogram structure to determine the base base type of a template argument. More...
struct	base_type< T, std::enable_if_t< is_complex< T >::value > >
	Template metaprogram defining the base type for values stored in a complex number. More...
struct	base_type< T, std::enable_if_t< is_eigen< T >::value > >
	Template metaprogram defining the base base type of values stored in an Eigen matrix. More...
struct	base_type< T, std::enable_if_t< is_std_vector< T >::value > >
	Specialization of base_type for vector to recursively return the inner base type. More...
struct	conditional_var_value
	Conditionally construct a var_value container based on a scalar type. More...
struct	conditional_var_value< T_scalar, T_container, require_std_vector_t< T_container > >
struct	error_index
struct	eval_return_type
	Determines return type of calling .eval() on Eigen expression. More...
struct	is_any_var_matrix
	Check if any types in a parameter pack are a var_value whose value_type is derived from Eigen::EigenBase More...
struct	is_arena_matrix
	Defines a static member named value which is defined to be true if the type is arena_matrix<T> More...
struct	is_arena_matrix< T, require_t< internal::is_arena_matrix_impl< std::decay_t< T > > > >
	Defines a static member named value which is defined to be true if the type is arena_matrix<T> More...
struct	is_arena_matrix_cl
struct	is_autodiff
	Checks if decayed type is a var or fvar. More...
struct	is_base_pointer_convertible
	Checks if a type's pointer is convertible to a templated base type's pointer. More...
struct	is_col_vector
	If the input type T has a static comple time constant type ColsAtCompileTime equal to 1 this has a static member with a value of true. More...
struct	is_complex
	If T is a complex type (that is, an instance of std::complex) or a cv-qualified version thereof, provides the member constant value equal true; for any other type the value is false. More...
struct	is_complex< T, std::enable_if_t< internal::is_complex_impl< std::decay_t< T > >::value > >
struct	is_complex_ad
	If T is a complex type with an inner autodiff type (that is, an instance of std::complex<var> or std::complex<fvar<T>>) or a cv-qualified version thereof, provides the member constant value equal true; for any other type the value is false. More...
struct	is_complex_ad< T, std::enable_if_t< stan::math::conjunction< is_autodiff< base_type_t< T > >, internal::is_complex_impl< std::decay_t< T > > >::value > >
struct	is_complex_arithmetic
	If T is a complex type with an inner arithmetic type (that is, an instance of std::complex<Arithmetic>) or a cv-qualified version thereof, provides the member constant value equal true; for any other type the value is false. More...
struct	is_complex_arithmetic< T, std::enable_if_t< stan::math::conjunction< std::is_arithmetic< base_type_t< T > >, internal::is_complex_impl< std::decay_t< T > > >::value > >
struct	is_constant
	Metaprogramming struct to detect whether a given type is constant in the mathematical sense (not the C++ const sense). More...
struct	is_constant< T, require_all_kernel_expressions_and_none_scalar_t< T > >
	Defines a static member named value and sets it to true if the type of the elements in the provided matrix_cl is constant, false otherwise. More...
struct	is_constant< T, require_eigen_t< T > >
	Defines a public enum named value and sets it to true if the type of the elements in the provided Eigen Matrix is constant, false otherwise. More...
struct	is_constant< T, require_std_vector_t< T > >
	Defines a static member named value and sets it to true if the type of the elements in the provided std::vector is constant, false otherwise. More...
struct	is_detected
struct	is_detected< T, Op, void_t< Op< T > > >
	Checks whether a valid type is detected. More...
struct	is_double_or_int
	Checks if decayed type is a double or integer. More...
struct	is_eigen
	Check if type derives from EigenBase More...
struct	is_eigen_array
	Check if a type is derived from Eigen::ArrayBase More...
struct	is_eigen_col_vector
	If the input type T is an eigen matrix with 1 row at compile time this has a static member with a value of true. More...
struct	is_eigen_contiguous_map
	Check if a type is an Eigen::Map with contiguous stride. More...
struct	is_eigen_dense_base
	Checks whether type T is derived from Eigen::DenseBase. More...
struct	is_eigen_matrix_base
	Checks whether type T is derived from Eigen::MatrixBase. More...
struct	is_eigen_matrix_dynamic
	Checks whether type T is derived from Eigen::MatrixBase and has columns and rows not equal to 1. More...
struct	is_eigen_row_vector
	If the input type T is an eigen matrix with 1 column at compile time this has a static member with a value of true. More...
struct	is_eigen_sparse_base
	Checks whether type T is derived from Eigen::SparseMatrixBase. More...
struct	is_eigen_vector
	If the input type T is an eigen matrix with 1 column or 1 row at compile time this has a static member with a value of true. More...
struct	is_fvar
	Defines a static member function type which is defined to be false as the primitive scalar types cannot be a stan::math::fvar type. More...
struct	is_fvar< T, std::enable_if_t< internal::is_fvar_impl< std::decay_t< T > >::value > >
struct	is_kernel_expression
	Determines whether a type is is a valid kernel generator expression. More...
struct	is_kernel_expression_and_not_scalar
	Determines whether a type is non-scalar type that is a valid kernel generator expression. More...
struct	is_kernel_expression_and_not_scalar< T, require_matrix_cl_t< T > >
struct	is_kernel_expression_lhs
	Determines whether a type is an assignable kernel generator expression. More...
struct	is_kernel_expression_lhs< T, require_matrix_cl_t< T > >
struct	is_matrix
	Check if a type is derived from Eigen::EigenBase or is a var_value whose value_type is derived from Eigen::EigenBase More...
struct	is_matrix_cl
	Checks if the decayed type of T is a matrix_cl. More...
struct	is_nonscalar_prim_or_rev_kernel_expression
	Determines whether a type is either a non-scalar kernel generator expression or a var containing a non-scalar kernel generator expression. More...
struct	is_prim_or_rev_kernel_expression
	Determines whether a type is either a kernel generator expression or a var containing a kernel generator expression. More...
struct	is_real
	Checks if decayed type is a var, fvar, or arithmetic. More...
struct	is_rev_col_vector
	Defines a static member named value which is defined to be true if the type is either derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase. More...
struct	is_rev_col_vector< T, require_all_t< is_var< scalar_type_t< T > >, math::disjunction< is_eigen_col_vector< T >, is_eigen_col_vector< value_type_t< T > > > > >
	Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase. More...
struct	is_rev_kernel_expression
	Determines whether a type is a var containing a kernel generator expression. More...
struct	is_rev_matrix
	Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase More...
struct	is_rev_matrix< T, require_all_t< is_var< scalar_type_t< T > >, math::disjunction< math::conjunction< is_var< T >, is_eigen< value_type_t< T > > >, is_eigen< T > > > >
	Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase More...
struct	is_rev_row_vector
	Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase. More...
struct	is_rev_row_vector< T, require_all_t< is_var< scalar_type_t< T > >, math::disjunction< is_eigen_row_vector< T >, is_eigen_row_vector< value_type_t< T > > > > >
	Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase. More...
struct	is_rev_vector
	Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase. More...
struct	is_rev_vector< T, require_any_t< is_rev_col_vector< T >, is_rev_row_vector< T > > >
	Defines a static member named value which is defined to be true if the type is either a type derived from Eigen::EigenBase with a Scalar type of var_value<double> or a var_value<T> where T is derived from Eigen::EigenBase. More...
struct	is_row_vector
	If the input type T has a static comple time constant type RowsAtCompileTime equal to 1 this has a static member with a value of true. More...
struct	is_stan_scalar
	Checks if decayed type is a var, fvar, or arithmetic. More...
struct	is_std_vector
	Base implementation for checking if type is std vector. More...
struct	is_std_vector< T, std::enable_if_t< internal::is_std_vector_impl< std::decay_t< T > >::value > >
	Checks if the decayed type of T is a standard vector. More...
struct	is_var
	Defines a static member named value which is defined to be false as the primitive scalar types cannot be a stan::math::var type. More...
struct	is_var< T, std::enable_if_t< internal::is_var_impl< std::decay_t< T > >::value > >
	Specialization for checking if value of T minus cv qualifier is a var_value. More...
struct	is_var_col_vector
	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase. More...
struct	is_var_dense_dynamic
	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase and has dynamic rows and columns. More...
struct	is_var_eigen
	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase More...
struct	is_var_matrix
	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase More...
struct	is_var_or_arithmetic_type
	Defines a static member value which is defined to be true (1) if the unqualified cv of type T or its underlying type (if a container) is either var or an arithmetic type, and false (0) otherwise. More...
struct	is_var_row_vector
	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase. More...
struct	is_var_vector
	Check if a type is a var_value whose value_type is derived from Eigen::EigenBase. More...
struct	is_vari
	Specialization for checking if value of T minus cv qualifier and pointer is a vari. More...
struct	is_vari< T, require_t< internal::is_vari_impl< std::decay_t< T > > > >
	Specialization for checking if value of T minus cv qualifier and pointer is a vari_value. More...
struct	is_vector
	If the input type T is either an eigen matrix with 1 column or 1 row at compile time or a standard vector, this has a static member with a value of true. More...
struct	is_vector_like
	Template metaprogram indicates whether a type is vector_like. More...
struct	is_vt_complex
	If the value_type of the type T is of type std::complex or a cv-qualified version thereof, provides the member constant value equal true; for any other type the value is false. More...
struct	is_vt_not_complex
	If the value_type of the type T is not of type std::complex or a cv-qualified version thereof, provides the member constant value equal true; for any other type the value is false. More...
struct	make_void
class	operation_cl_base
	Non-templated base of operation_cl is needed for easy checking if something is a subclass of operation_cl. More...
class	operation_cl_lhs_base
	Non-templated base of operation_cl_lhs is needed for easy checking if something is a subclass of operation_cl_lhs. More...
struct	partials_return_type
	Template metaprogram to calculate the partial derivative type resulting from promoting all the scalar types of the template parameters. More...
struct	partials_return_type< T >
struct	partials_type
	This base implementation will contain a static member function named type equal to the type passed into it. More...
struct	partials_type< T, require_fvar_t< T > >
struct	partials_type< T, require_var_t< T > >
	Specialization of partials type returns double if input type is a double. More...
struct	plain_type
	Determines plain (non expression) type associated with T. More...
struct	plain_type< T, require_all_kernel_expressions_and_none_scalar_t< T > >
	Determines plain (non expression) type associated with T. More...
struct	plain_type< T, require_t< bool_constant< internal::has_eval< T >::value &&is_eigen< T >::value > > >
	Determines plain (non expression) type associated with T. More...
struct	plain_type< T, require_t< bool_constant<!internal::has_eval< T >::value &&internal::has_plain_object< T >::value &&is_eigen< T >::value > > >
struct	plain_type< T, require_t< stan::math::conjunction< is_var< T >, is_eigen< value_type_t< T > > > > >
	Determines plain (non expression) type associated with T. More...
struct	real_return
	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	real_return< T, Ts... >
struct	ref_type_if
	If the condition is true determines appropriate type for assigning expression of given type to, to evaluate expensive expressions, but not make a copy if T involves no calculations. More...
struct	ref_type_if< Condition, T, require_all_kernel_expressions_t< T > >
struct	ref_type_if< Condition, T, require_all_t< is_eigen< T >, bool_constant<!is_arena_matrix< T >::value > > >
struct	ref_type_if< Condition, T, require_arena_matrix_t< T > >
struct	return_type
	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...
struct	rev_matrix_type
	Determines a return type for a function that accepts given inputs and wants to return a matrix (or vector or row vector) with given compile time number of rows and columns. More...
struct	scalar_lub
	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	scalar_lub< std::complex< T1 >, std::complex< T2 > >
struct	scalar_lub< std::complex< T1 >, T2 >
struct	scalar_lub< T1, std::complex< T2 > >
class	scalar_seq_view
	scalar_seq_view provides a uniform sequence-like wrapper around either a scalar or a sequence of scalars. More...
class	scalar_seq_view< C, require_eigen_vector_t< C > >
class	scalar_seq_view< C, require_stan_scalar_t< C > >
	This specialization handles wrapping a scalar as if it were a sequence. More...
class	scalar_seq_view< C, require_std_vector_t< C > >
class	scalar_seq_view< C, require_t< std::is_pointer< C > > >
class	scalar_seq_view< C, require_var_matrix_t< C > >
struct	scalar_type
	Metaprogram structure to determine the base scalar type of a template argument. More...
struct	scalar_type< T, require_all_kernel_expressions_and_none_scalar_t< T > >
	Return the scalar type of an OpenCL matrix. More...
struct	scalar_type< T, std::enable_if_t< is_complex< T >::value > >
	Template metaprogram defining the scalar type for values stored in a complex number. More...
struct	scalar_type< T, std::enable_if_t< is_eigen< T >::value &&!internal::has_scalar_trait< T >::value > >
	Template metaprogram defining the base scalar type of values stored in an Eigen matrix. More...
struct	scalar_type< T, std::enable_if_t< is_eigen< T >::value &&internal::has_scalar_trait< T >::value > >
	Template metaprogram defining the base scalar type of values stored in an Eigen matrix. More...
struct	scalar_type< T, std::enable_if_t< is_std_vector< T >::value > >
	Specialization of scalar_type for vector to recursively return the inner scalar type. More...
struct	scalar_type< T, std::enable_if_t< is_var< T >::value > >
	Template specialization defining the scalar type of values stored in var_value. More...
class	StdVectorBuilder
	StdVectorBuilder allocates type T1 values to be used as intermediate values. More...
struct	value_type
	Primary template class for metaprogram to compute the type of values stored in a container. More...
struct	value_type< T, require_all_kernel_expressions_and_none_scalar_t< T > >
	Return the value type of an OpenCL matrix. More...
struct	value_type< T, require_t< is_vari< T > > >
struct	value_type< T, std::enable_if_t< is_eigen< T >::value &&!internal::has_scalar_trait< T >::value > >
	Template metaprogram defining the type of values stored in an Eigen matrix, vector, or row vector. More...
struct	value_type< T, std::enable_if_t< is_eigen< T >::value &&internal::has_scalar_trait< T >::value > >
	Template metaprogram defining the type of values stored in an Eigen matrix, vector, or row vector. More...
struct	value_type< T, std::enable_if_t< is_std_vector< T >::value > >
	Template metaprogram class to compute the type of values stored in a standard vector. More...
struct	value_type< T, std::enable_if_t< is_var< T >::value > >
struct	value_type< T, std::enable_if_t< std::is_pointer< T >::value > >
	Specialization for pointers returns the underlying value the pointer is pointing to. More...
class	vector_seq_view
	This class provides a low-cost wrapper for situations where you either need an Eigen Vector or RowVector or a std::vector of them and you want to be agnostic between those two options. More...
class	vector_seq_view< T, require_matrix_t< T > >
	This class provides a low-cost wrapper for situations where you either need an Eigen Vector or RowVector or a std::vector of them and you want to be agnostic between those two options. More...
class	vector_seq_view< T, require_std_vector_vt< internal::is_matrix_or_std_vector, T > >
	This class provides a low-cost wrapper for situations where you either need an Eigen Vector or RowVector or a std::vector of them and you want to be agnostic between those two options. More...
class	VectorBuilder
	VectorBuilder allocates type T1 values to be used as intermediate values. More...
class	VectorBuilderHelper
	VectorBuilder allocates type T1 values to be used as intermediate values. More...
class	VectorBuilderHelper< T1, true, false >
class	VectorBuilderHelper< T1, true, true >
	Template specialization for using a vector. More...

Typedefs
template<typename T >
using	base_type_t = typename base_type< T >::type
template<bool B>
using	bool_constant = std::integral_constant< bool, B >
	Alias for structs used for wraps a static constant of bool.
template<typename... Ts>
using	contains_std_vector = math::disjunction< is_std_vector< Ts >... >
	Checks if any types are std vectors.
template<typename T >
using	require_arena_matrix_t = require_t< is_arena_matrix< std::decay_t< T > > >
	Require type satisfies is_arena_matrix.
template<typename T >
using	require_not_arena_matrix_t = require_t< bool_constant<!is_arena_matrix< std::decay_t< T > >::value > >
	Require type does not satisfy is_arena_matrix.
template<typename T >
using	require_autodiff_t = require_t< is_autodiff< std::decay_t< T > > >
	Require type satisfies is_autodiff.
template<typename T >
using	require_not_autodiff_t = require_not_t< is_autodiff< std::decay_t< T > > >
	Require type does not satisfy is_autodiff.
template<typename... Types>
using	require_all_autodiff_t = require_all_t< is_autodiff< std::decay_t< Types > >... >
	Require all of the types satisfy is_autodiff.
template<typename... Types>
using	require_any_autodiff_t = require_any_t< is_autodiff< std::decay_t< Types > >... >
	Require any of the types satisfy is_autodiff.
template<typename... Types>
using	require_all_not_autodiff_t = require_all_not_t< is_autodiff< std::decay_t< Types > >... >
	Require none of the types satisfy is_autodiff.
template<typename... Types>
using	require_any_not_autodiff_t = require_any_not_t< is_autodiff< std::decay_t< Types > >... >
	Require at least one of the types do not satisfy is_autodiff.
template<typename T >
using	require_not_vt_autodiff = require_not_t< is_autodiff< value_type_t< std::decay_t< T > > > >
	Require value type does not satisfy is_autodiff.
template<typename... Types>
using	require_all_not_vt_autodiff = require_all_not_t< is_autodiff< value_type_t< std::decay_t< Types > > >... >
	Require none of the value types satisfy is_autodiff.
template<typename T >
using	require_st_autodiff = require_t< is_autodiff< scalar_type_t< std::decay_t< T > > > >
	Require scalar type satisfies is_autodiff.
template<typename T >
using	require_not_st_autodiff = require_not_t< is_autodiff< scalar_type_t< std::decay_t< T > > > >
	Require scalar type does not satisfy is_autodiff.
template<typename... Types>
using	require_any_st_autodiff = require_any_t< is_autodiff< scalar_type_t< std::decay_t< Types > > >... >
	Require any of the scalar types satisfy is_autodiff.
template<typename T >
using	require_complex_t = require_t< is_complex< std::decay_t< T > > >
	Require type satisfies is_complex.
template<typename T >
using	require_not_complex_t = require_not_t< is_complex< std::decay_t< T > > >
	Require type does not satisfy is_complex.
template<typename... Types>
using	require_all_complex_t = require_all_t< is_complex< std::decay_t< Types > >... >
	Require all of the types satisfy is_complex.
template<typename... Types>
using	require_any_complex_t = require_any_t< is_complex< std::decay_t< Types > >... >
	Require any of the types satisfy is_complex.
template<typename... Types>
using	require_all_not_complex_t = require_all_not_t< is_complex< std::decay_t< Types > >... >
	Require none of the types satisfy is_complex.
template<typename T >
using	require_vt_complex = require_t< is_complex< value_type_t< std::decay_t< T > > > >
	Require value type satisfies is_complex.
template<typename T >
using	require_not_vt_complex = require_not_t< is_complex< value_type_t< std::decay_t< T > > > >
	Require value type does not satisfy is_complex.
template<typename T >
using	require_not_st_complex = require_not_t< is_complex< scalar_type_t< std::decay_t< T > > > >
	Require scalar type does not satisfy is_complex.
template<template< class... > class TypeCheck, class Check >
using	require_complex_bt = require_all_t< is_complex< Check >, TypeCheck< base_type_t< Check > > >
	Require type satisfies is_eigen.
template<typename... T>
using	is_constant_all = math::conjunction< is_constant< T >... >
	Metaprogram defining an enum value which is true if all of the type parameters are constant (i.e., primitive types) and false otherwise.
template<typename Container >
using	is_container = bool_constant< math::disjunction< is_eigen< Container >, is_std_vector< Container > >::value >
	Deduces whether type is eigen matrix or standard vector.
template<typename T >
using	require_container_t = require_t< is_container< std::decay_t< T > > >
	Require type satisfies is_container.
template<typename T >
using	require_not_container_t = require_not_t< is_container< std::decay_t< T > > >
	Require type does not satisfy is_container.
template<typename... Types>
using	require_all_container_t = require_all_t< is_container< std::decay_t< Types > >... >
	Require all of the types satisfy is_container.
template<typename... Types>
using	require_any_container_t = require_any_t< is_container< std::decay_t< Types > >... >
	Require any of the types satisfy is_container.
template<typename... Types>
using	require_all_not_container_t = require_all_not_t< is_container< std::decay_t< Types > >... >
	Require none of the types satisfy is_container.
template<template< class... > class TypeCheck, class... Check>
using	require_container_st = require_t< container_type_check_base< is_container, scalar_type_t, TypeCheck, Check... > >
	Require type satisfies is_container.
template<template< class... > class TypeCheck, class... Check>
using	require_container_bt = require_t< container_type_check_base< is_container, base_type_t, TypeCheck, Check... > >
	Require type satisfies is_container.
template<template< class... > class TypeCheck, class... Check>
using	require_not_container_st = require_not_t< container_type_check_base< is_container, scalar_type_t, TypeCheck, Check... > >
	Require type does not satisfy is_container.
template<typename T >
using	require_ad_container_t = require_all_t< stan::math::disjunction< is_eigen< T >, is_std_vector< T > >, is_autodiff< base_type_t< T > > >
	Require type satisfies is_container.
template<typename Container >
using	is_container_or_var_matrix = bool_constant< math::disjunction< is_container< Container >, is_var_matrix< Container > >::value >
	Deduces whether type is eigen matrix, standard vector, or var<Matrix>.
template<typename T >
using	is_dense_dynamic = internal::is_dense_dynamic_impl< std::decay_t< T > >
	Checks whether type T is derived from Eigen::DenseBase and has dynamic rows and columns or is a var_value<> whose inner type satisfies the conditions above.
template<typename T >
using	require_dense_dynamic_t = require_t< is_dense_dynamic< std::decay_t< T > > >
	Require type satisfies is_dense_dynamic.
template<typename... Types>
using	require_all_dense_dynamic_t = require_all_t< is_dense_dynamic< std::decay_t< Types > >... >
	Require all of the types satisfy is_dense_dynamic.
template<typename T >
using	require_double_or_int_t = require_t< is_double_or_int< std::decay_t< T > > >
	Require type satisfies is_double_or_int.
template<typename T >
using	require_not_double_or_int_t = require_not_t< is_double_or_int< std::decay_t< T > > >
	Require type does not satisfy is_double_or_int.
template<typename... Types>
using	require_all_double_or_int_t = require_all_t< is_double_or_int< std::decay_t< Types > >... >
	Require all of the types satisfy is_double_or_int.
template<typename... Types>
using	require_any_double_or_int_t = require_any_t< is_double_or_int< std::decay_t< Types > >... >
	Require any of the types satisfy is_double_or_int.
template<typename... Types>
using	require_all_not_double_or_int_t = require_all_not_t< is_double_or_int< std::decay_t< Types > >... >
	Require none of the types satisfy is_double_or_int.
template<typename... Types>
using	require_any_not_double_or_int_t = require_any_not_t< is_double_or_int< std::decay_t< Types > >... >
	Require at least one of the types do not satisfy is_double_or_int.
template<typename T >
using	require_eigen_t = require_t< is_eigen< std::decay_t< T > > >
	Require type satisfies is_eigen.
template<typename T >
using	require_not_eigen_t = require_not_t< is_eigen< std::decay_t< T > > >
	Require type does not satisfy is_eigen.
template<typename... Types>
using	require_all_eigen_t = require_all_t< is_eigen< std::decay_t< Types > >... >
	Require all of the types satisfy is_eigen.
template<typename... Types>
using	require_any_eigen_t = require_any_t< is_eigen< std::decay_t< Types > >... >
	Require any of the types satisfy is_eigen.
template<typename... Types>
using	require_all_not_eigen_t = require_all_not_t< is_eigen< std::decay_t< Types > >... >
	Require none of the types satisfy is_eigen.
template<typename... Types>
using	require_any_not_eigen_t = require_any_not_t< is_eigen< std::decay_t< Types > >... >
	Require at least one of the types do not satisfy is_eigen.
template<template< class... > class TypeCheck, class... Check>
using	require_eigen_vt = require_t< container_type_check_base< is_eigen, value_type_t, TypeCheck, Check... > >
	Require type satisfies is_eigen.
template<template< class... > class TypeCheck, class... Check>
using	require_not_eigen_vt = require_not_t< container_type_check_base< is_eigen, value_type_t, TypeCheck, Check... > >
	Require type does not satisfy is_eigen or.
template<template< class... > class TypeCheck, class... Check>
using	require_any_eigen_vt = require_any_t< container_type_check_base< is_eigen, value_type_t, TypeCheck, Check >... >
	Require any of the types satisfy is_eigen.
template<template< class... > class TypeCheck, class... Check>
using	require_any_not_eigen_vt = require_any_not_t< container_type_check_base< is_eigen, value_type_t, TypeCheck, Check >... >
	Require at least one of the types does not satisfy is_eigen.
template<template< class... > class TypeCheck, class... Check>
using	require_all_eigen_vt = require_all_t< container_type_check_base< is_eigen, value_type_t, TypeCheck, Check >... >
	Require all of the types satisfy is_eigen.
template<template< class... > class TypeCheck, class... Check>
using	require_all_not_eigen_vt = require_all_not_t< container_type_check_base< is_eigen, value_type_t, TypeCheck, Check >... >
	Require none of the types satisfy is_eigen.
template<template< class... > class TypeCheck, class... Check>
using	require_eigen_st = require_t< container_type_check_base< is_eigen, scalar_type_t, TypeCheck, Check... > >
	Require type satisfies is_eigen.
template<template< class... > class TypeCheck, class... Check>
using	require_not_eigen_st = require_not_t< container_type_check_base< is_eigen, scalar_type_t, TypeCheck, Check... > >
	Require type does not satisfy is_eigen.
template<template< class... > class TypeCheck, class... Check>
using	require_any_eigen_st = require_any_t< container_type_check_base< is_eigen, scalar_type_t, TypeCheck, Check >... >
	Require any of the types satisfy is_eigen.
template<template< class... > class TypeCheck, class... Check>
using	require_any_not_eigen_st = require_any_not_t< container_type_check_base< is_eigen, scalar_type_t, TypeCheck, Check >... >
	Require at least one of the types does not satisfy is_eigen.
template<template< class... > class TypeCheck, class... Check>
using	require_all_eigen_st = require_all_t< container_type_check_base< is_eigen, scalar_type_t, TypeCheck, Check >... >
	Require all of the types does not satisfy is_eigen.
template<template< class... > class TypeCheck, class... Check>
using	require_all_not_eigen_st = require_all_not_t< container_type_check_base< is_eigen, scalar_type_t, TypeCheck, Check >... >
	Require none of the types satisfy is_eigen.
template<typename T >
using	require_eigen_array_t = require_t< is_eigen_array< std::decay_t< T > > >
	Require type satisfies is_eigen_array.
template<typename T >
using	require_not_eigen_array_t = require_not_t< is_eigen_array< std::decay_t< T > > >
	Require type does not satisfy is_eigen_array.
template<typename... Types>
using	require_any_eigen_array_t = require_any_t< is_eigen_array< std::decay_t< Types > >... >
	Require any of the types satisfy is_eigen_array.
template<typename T >
using	is_eigen_matrix_or_array = math::disjunction< is_eigen_matrix_base< T >, is_eigen_array< T > >
	Check if a type is derived from Eigen::MatrixBase or Eigen::ArrayBase
template<template< class... > class TypeCheck, class... Check>
using	require_eigen_array_vt = require_t< container_type_check_base< is_eigen_array, value_type_t, TypeCheck, Check... > >
	Require type satisfies is_eigen_array.
template<typename T >
using	require_eigen_dense_base_t = require_t< is_eigen_dense_base< std::decay_t< T > > >
	Require type satisfies is_eigen_dense_base.
template<template< class... > class TypeCheck, class... Check>
using	require_eigen_dense_base_vt = require_t< container_type_check_base< is_eigen_dense_base, value_type_t, TypeCheck, Check... > >
	Require type satisfies is_eigen_dense_base.
template<typename T >
using	is_eigen_dense_dynamic = stan::internal::is_eigen_matrix_dynamic_impl< std::decay_t< T >, stan::is_eigen_dense_base< std::decay_t< T > >::value >
	Checks whether type T is derived from Eigen::DenseBase and has dynamic rows and columns.
template<typename T >
using	require_eigen_dense_dynamic_t = require_t< is_eigen_dense_dynamic< std::decay_t< T > > >
	Require type satisfies is_eigen_dense_dynamic.
template<typename... Types>
using	require_all_eigen_dense_dynamic_t = require_all_t< is_eigen_dense_dynamic< std::decay_t< Types > >... >
	Require all of the types satisfy is_eigen_dense_dynamic.
template<template< class... > class TypeCheck, class... Check>
using	require_eigen_dense_dynamic_vt = require_t< container_type_check_base< is_eigen_dense_dynamic, value_type_t, TypeCheck, Check... > >
	Require type satisfies is_eigen_dense_dynamic.
template<typename T >
using	require_eigen_matrix_dynamic_t = require_t< is_eigen_matrix_dynamic< std::decay_t< T > > >
	Require type satisfies is_eigen_matrix_dynamic.
template<typename... Types>
using	require_all_eigen_matrix_dynamic_t = require_all_t< is_eigen_matrix_dynamic< std::decay_t< Types > >... >
	Require all of the types satisfy is_eigen_matrix_dynamic.
template<typename... Types>
using	require_any_eigen_matrix_dynamic_t = require_any_t< is_eigen_matrix_dynamic< std::decay_t< Types > >... >
	Require any of the types satisfy is_eigen_matrix_dynamic.
template<template< class... > class TypeCheck, class... Check>
using	require_eigen_matrix_dynamic_vt = require_t< container_type_check_base< is_eigen_matrix_dynamic, value_type_t, TypeCheck, Check... > >
	Require type satisfies is_eigen_matrix_dynamic.
template<typename T >
using	require_eigen_matrix_base_t = require_t< is_eigen_matrix_base< std::decay_t< T > > >
	Require type satisfies is_eigen_matrix_base.
template<template< class... > class TypeCheck, class... Check>
using	require_eigen_matrix_base_vt = require_t< container_type_check_base< is_eigen_matrix_base, value_type_t, TypeCheck, Check... > >
	Require type satisfies is_eigen_matrix_base.
template<template< class... > class TypeCheck, class... Check>
using	require_all_eigen_matrix_base_vt = require_all_t< container_type_check_base< is_eigen_matrix_base, value_type_t, TypeCheck, Check >... >
	Require all of the types satisfy is_eigen_matrix_base.
template<typename T >
using	require_eigen_sparse_base_t = require_t< is_eigen_sparse_base< std::decay_t< T > > >
	Require type satisfies is_eigen_sparse_base.
template<typename T >
using	require_fvar_t = require_t< is_fvar< std::decay_t< T > > >
	Require type satisfies is_fvar.
template<typename T >
using	require_not_fvar_t = require_not_t< is_fvar< std::decay_t< T > > >
	Require type does not satisfy is_fvar.
template<typename... Types>
using	require_all_fvar_t = require_all_t< is_fvar< std::decay_t< Types > >... >
	Require all of the types satisfy is_fvar.
template<typename... Types>
using	require_any_fvar_t = require_any_t< is_fvar< std::decay_t< Types > >... >
	Require any of the types satisfy is_fvar.
template<typename... Types>
using	require_all_not_fvar_t = require_all_not_t< is_fvar< std::decay_t< Types > >... >
	Require none of the types satisfy is_fvar.
template<typename... Types>
using	require_any_not_fvar_t = require_any_not_t< is_fvar< std::decay_t< Types > >... >
	Require at least one of the types do not satisfy is_fvar.
template<typename... Types>
using	require_any_vt_fvar = require_any_t< is_fvar< value_type_t< std::decay_t< Types > > >... >
	Require any of the value types satisfy is_fvar.
template<typename... Types>
using	require_all_not_vt_fvar = require_all_not_t< is_fvar< value_type_t< std::decay_t< Types > > >... >
	Require none of the value types satisfy is_fvar.
template<typename T >
using	require_st_fvar = require_t< is_fvar< scalar_type_t< std::decay_t< T > > > >
	Require scalar type satisfies is_fvar.
template<typename T >
using	require_not_st_fvar = require_not_t< is_fvar< scalar_type_t< std::decay_t< T > > > >
	Require scalar type does not satisfy is_fvar.
template<typename... Types>
using	require_any_st_fvar = require_any_t< is_fvar< scalar_type_t< std::decay_t< Types > > >... >
	Require any of the scalar types satisfy is_fvar.
template<typename... Types>
using	require_all_not_st_fvar = require_all_not_t< is_fvar< scalar_type_t< std::decay_t< Types > > >... >
	Require none of the scalar types satisfy is_fvar.
template<typename... Types>
using	require_all_kernel_expressions_and_none_scalar_t = require_all_t< is_kernel_expression_and_not_scalar< Types >... >
	Enables a template if all given types are non-scalar types that are a valid kernel generator expressions.
template<typename... Types>
using	require_all_kernel_expressions_t = require_all_t< is_kernel_expression< Types >... >
	Enables a template if all given types are are a valid kernel generator expressions.
template<typename T >
using	require_kernel_expression_lhs_t = require_t< is_kernel_expression_lhs< std::decay_t< T > > >
	Require type satisfies is_kernel_expression_lhs.
template<typename T >
using	require_rev_kernel_expression_t = require_t< is_rev_kernel_expression< std::decay_t< T > > >
	Require type satisfies is_rev_kernel_expression.
template<typename T >
using	require_not_rev_kernel_expression_t = require_not_t< is_rev_kernel_expression< std::decay_t< T > > >
	Require type does not satisfy is_rev_kernel_expression.
template<typename... Types>
using	require_all_prim_or_rev_kernel_expression_t = require_all_t< is_prim_or_rev_kernel_expression< std::decay_t< Types > >... >
	Require type satisfies is_prim_or_rev_kernel_expression.
template<typename T >
using	require_nonscalar_prim_or_rev_kernel_expression_t = require_t< is_nonscalar_prim_or_rev_kernel_expression< std::decay_t< T > > >
	Require type satisfies is_nonscalar_prim_or_rev_kernel_expression.
template<typename T >
using	require_not_nonscalar_prim_or_rev_kernel_expression_t = require_not_t< is_nonscalar_prim_or_rev_kernel_expression< std::decay_t< T > > >
	Require type does not satisfy is_nonscalar_prim_or_rev_kernel_expression.
template<typename... Types>
using	require_all_nonscalar_prim_or_rev_kernel_expression_t = require_all_t< is_nonscalar_prim_or_rev_kernel_expression< std::decay_t< Types > >... >
	Require all of the types satisfy is_nonscalar_prim_or_rev_kernel_expression.
template<typename... Types>
using	require_any_nonscalar_prim_or_rev_kernel_expression_t = require_any_t< is_nonscalar_prim_or_rev_kernel_expression< std::decay_t< Types > >... >
	Require any of the types satisfy is_nonscalar_prim_or_rev_kernel_expression.
template<typename... Types>
using	require_all_not_nonscalar_prim_or_rev_kernel_expression_t = require_all_not_t< is_nonscalar_prim_or_rev_kernel_expression< std::decay_t< Types > >... >
	Require none of the types satisfy is_nonscalar_prim_or_rev_kernel_expression.
template<typename T >
using	require_matrix_t = require_t< is_matrix< std::decay_t< T > > >
	Require type satisfies is_matrix.
template<typename T >
using	require_not_matrix_t = require_not_t< is_matrix< std::decay_t< T > > >
	Require type does not satisfy is_matrix.
template<typename... Types>
using	require_all_matrix_t = require_all_t< is_matrix< std::decay_t< Types > >... >
	Require all of the types satisfy is_matrix.
template<typename... Types>
using	require_any_matrix_t = require_any_t< is_matrix< std::decay_t< Types > >... >
	Require any of the types satisfy is_matrix.
template<typename... Types>
using	require_all_not_matrix_t = require_all_not_t< is_matrix< std::decay_t< Types > >... >
	Require none of the types satisfy is_matrix.
template<template< class... > class TypeCheck, class... Check>
using	require_any_matrix_st = require_any_t< container_type_check_base< is_matrix, scalar_type_t, TypeCheck, Check >... >
	Require any of the types satisfy is_matrix.
template<template< class... > class TypeCheck, class... Check>
using	require_all_matrix_st = require_all_t< container_type_check_base< is_matrix, scalar_type_t, TypeCheck, Check >... >
	Require all of the types does not satisfy is_matrix.
template<template< class... > class TypeCheck, class... Check>
using	require_all_not_matrix_st = require_all_not_t< container_type_check_base< is_matrix, scalar_type_t, TypeCheck, Check >... >
	Require none of the types satisfy is_matrix.
template<typename T >
using	require_matrix_cl_t = require_t< is_matrix_cl< std::decay_t< T > > >
	Require type satisfies is_matrix_cl.
template<typename T >
using	require_not_matrix_cl_t = require_not_t< is_matrix_cl< std::decay_t< T > > >
	Require type does not satisfy is_matrix_cl.
template<typename... Types>
using	require_all_matrix_cl_t = require_all_t< is_matrix_cl< std::decay_t< Types > >... >
	Require all of the types satisfy is_matrix_cl.
template<typename... Types>
using	require_any_matrix_cl_t = require_any_t< is_matrix_cl< std::decay_t< Types > >... >
	Require any of the types satisfy is_matrix_cl.
template<typename... Types>
using	require_all_not_matrix_cl_t = require_all_not_t< is_matrix_cl< std::decay_t< Types > >... >
	Require none of the types satisfy is_matrix_cl.
template<typename... Types>
using	require_any_not_matrix_cl_t = require_any_not_t< is_matrix_cl< std::decay_t< Types > >... >
	Require at least one of the types do not satisfy is_matrix_cl.
template<template< class... > class TypeCheck, class... Check>
using	require_matrix_cl_vt = require_t< container_type_check_base< is_matrix_cl, value_type_t, TypeCheck, Check... > >
	Require type satisfies is_matrix_cl.
template<template< class... > class TypeCheck, class... Check>
using	require_not_matrix_cl_vt = require_not_t< container_type_check_base< is_matrix_cl, value_type_t, TypeCheck, Check... > >
	Require type does not satisfy is_matrix_cl or.
template<template< class... > class TypeCheck, class... Check>
using	require_any_matrix_cl_vt = require_any_t< container_type_check_base< is_matrix_cl, value_type_t, TypeCheck, Check >... >
	Require any of the types satisfy is_matrix_cl.
template<template< class... > class TypeCheck, class... Check>
using	require_any_not_matrix_cl_vt = require_any_not_t< container_type_check_base< is_matrix_cl, value_type_t, TypeCheck, Check >... >
	Require at least one of the types does not satisfy is_matrix_cl.
template<template< class... > class TypeCheck, class... Check>
using	require_all_matrix_cl_vt = require_all_t< container_type_check_base< is_matrix_cl, value_type_t, TypeCheck, Check >... >
	Require all of the types satisfy is_matrix_cl.
template<template< class... > class TypeCheck, class... Check>
using	require_all_not_matrix_cl_vt = require_all_not_t< container_type_check_base< is_matrix_cl, value_type_t, TypeCheck, Check >... >
	Require none of the types satisfy is_matrix_cl.
template<template< class... > class TypeCheck, class... Check>
using	require_matrix_cl_st = require_t< container_type_check_base< is_matrix_cl, scalar_type_t, TypeCheck, Check... > >
	Require type satisfies is_matrix_cl.
template<typename S >
using	is_plain_type = std::is_same< std::decay_t< S >, plain_type_t< S > >
	Checks whether the template type T is an assignable type.
template<typename T >
using	require_plain_type_t = require_t< is_plain_type< std::decay_t< T > > >
	Require type satisfies is_plain_type.
template<typename T >
using	require_not_plain_type_t = require_not_t< is_plain_type< std::decay_t< T > > >
	Require type does not satisfy is_plain_type.
template<typename... Types>
using	require_all_plain_type_t = require_all_t< is_plain_type< std::decay_t< Types > >... >
	Require all of the types satisfy is_plain_type.
template<typename... Types>
using	require_any_not_plain_type_t = require_any_not_t< is_plain_type< std::decay_t< Types > >... >
	Require any of the types satisfy is_plain_type.
template<typename T >
using	require_real_t = require_t< is_real< std::decay_t< T > > >
	Require type satisfies is_real.
template<typename T >
using	require_not_real_t = require_not_t< is_real< std::decay_t< T > > >
	Require type does not satisfy is_real.
template<typename... Types>
using	require_all_real_t = require_all_t< is_real< std::decay_t< Types > >... >
	Require all of the types satisfy is_real.
template<typename... Types>
using	require_any_real_t = require_any_t< is_real< std::decay_t< Types > >... >
	Require any of the types satisfy is_real.
template<typename... Types>
using	require_all_not_real_t = require_all_not_t< is_real< std::decay_t< Types > >... >
	Require none of the types satisfy is_real.
template<typename... Types>
using	require_any_not_real_t = require_any_not_t< is_real< std::decay_t< Types > >... >
	Require at least one of the types do not satisfy is_real.
template<typename T >
using	require_rev_matrix_t = require_t< is_rev_matrix< std::decay_t< T > > >
	Require type satisfies is_rev_matrix.
template<typename T >
using	require_not_rev_matrix_t = require_not_t< is_rev_matrix< std::decay_t< T > > >
	Require type does not satisfy is_rev_matrix.
template<typename... Types>
using	require_all_rev_matrix_t = require_all_t< is_rev_matrix< std::decay_t< Types > >... >
	Require all of the types satisfy is_rev_matrix.
template<typename... Types>
using	require_any_rev_matrix_t = require_any_t< is_rev_matrix< std::decay_t< Types > >... >
	Require any of the types satisfy is_rev_matrix.
template<typename... Types>
using	require_all_not_rev_matrix_t = require_all_not_t< is_rev_matrix< std::decay_t< Types > >... >
	Require none of the types satisfy is_rev_matrix.
template<typename T >
using	require_rev_col_vector_t = require_t< is_rev_col_vector< std::decay_t< T > > >
	Require type satisfies is_rev_col_vector.
template<typename T >
using	require_rev_vector_t = require_t< is_rev_vector< std::decay_t< T > > >
	Require type satisfies is_rev_vector.
template<typename T >
using	require_stan_scalar_t = require_t< is_stan_scalar< std::decay_t< T > > >
	Require type satisfies is_stan_scalar.
template<typename T >
using	require_not_stan_scalar_t = require_not_t< is_stan_scalar< std::decay_t< T > > >
	Require type does not satisfy is_stan_scalar.
template<typename... Types>
using	require_all_stan_scalar_t = require_all_t< is_stan_scalar< std::decay_t< Types > >... >
	Require all of the types satisfy is_stan_scalar.
template<typename... Types>
using	require_any_stan_scalar_t = require_any_t< is_stan_scalar< std::decay_t< Types > >... >
	Require any of the types satisfy is_stan_scalar.
template<typename... Types>
using	require_all_not_stan_scalar_t = require_all_not_t< is_stan_scalar< std::decay_t< Types > >... >
	Require none of the types satisfy is_stan_scalar.
template<typename... Types>
using	require_any_not_stan_scalar_t = require_any_not_t< is_stan_scalar< std::decay_t< Types > >... >
	Require at least one of the types do not satisfy is_stan_scalar.
template<typename T >
using	require_not_vt_stan_scalar = require_not_t< is_stan_scalar< value_type_t< std::decay_t< T > > > >
	Require value type does not satisfy is_stan_scalar.
template<typename T >
using	require_st_stan_scalar = require_t< is_stan_scalar< scalar_type_t< std::decay_t< T > > > >
	Require scalar type satisfies is_stan_scalar.
template<typename T >
using	require_not_st_stan_scalar = require_not_t< is_stan_scalar< scalar_type_t< std::decay_t< T > > > >
	Require scalar type does not satisfy is_stan_scalar.
template<typename... Types>
using	require_all_st_stan_scalar = require_all_t< is_stan_scalar< scalar_type_t< std::decay_t< Types > > >... >
	Require all of the scalar types satisfy is_stan_scalar.
template<typename T >
using	is_stan_scalar_or_eigen = bool_constant< is_stan_scalar< std::decay_t< T > >::value||is_eigen< std::decay_t< T > >::value >
	Extends std::true_type if all the provided types are either a Stan Scalar type or a type inheriting from EigenBase.
template<typename T >
using	require_stan_scalar_or_eigen_t = require_t< is_stan_scalar_or_eigen< std::decay_t< T > > >
	Require type satisfies is_stan_scalar_or_eigen.
template<typename T >
using	is_string_convertible = std::is_convertible< T, std::string >
	Deduces whether type is convertible to string.
template<typename T >
using	require_string_convertible_t = require_t< is_string_convertible< std::decay_t< T > > >
	Require type satisfies is_string_convertible.
template<typename T >
using	require_not_string_convertible_t = require_not_t< is_string_convertible< std::decay_t< T > > >
	Require type does not satisfy is_string_convertible.
template<typename... Types>
using	require_all_string_convertible_t = require_all_t< is_string_convertible< std::decay_t< Types > >... >
	Require all of the types satisfy is_string_convertible.
template<typename... Types>
using	require_any_string_convertible_t = require_any_t< is_string_convertible< std::decay_t< Types > >... >
	Require any of the types satisfy is_string_convertible.
template<typename... Types>
using	require_all_not_string_convertible_t = require_all_not_t< is_string_convertible< std::decay_t< Types > >... >
	Require none of the types satisfy is_string_convertible.
template<typename... Types>
using	require_any_not_string_convertible_t = require_any_not_t< is_string_convertible< std::decay_t< Types > >... >
	Require at least one of the types do not satisfy is_string_convertible.
template<typename T >
using	require_var_t = require_t< is_var< std::decay_t< T > > >
	Require type satisfies is_var.
template<typename T >
using	require_not_var_t = require_not_t< is_var< std::decay_t< T > > >
	Require type does not satisfy is_var.
template<typename... Types>
using	require_all_var_t = require_all_t< is_var< std::decay_t< Types > >... >
	Require all of the types satisfy is_var.
template<typename... Types>
using	require_any_var_t = require_any_t< is_var< std::decay_t< Types > >... >
	Require any of the types satisfy is_var.
template<typename... Types>
using	require_all_not_var_t = require_all_not_t< is_var< std::decay_t< Types > >... >
	Require none of the types satisfy is_var.
template<typename... Types>
using	require_any_not_var_t = require_any_not_t< is_var< std::decay_t< Types > >... >
	Require at least one of the types do not satisfy is_var.
template<template< class... > class TypeCheck, class... Check>
using	require_var_vt = require_t< container_type_check_base< is_var, value_type_t, TypeCheck, Check... > >
	Require type satisfies is_var.
template<template< class... > class TypeCheck, class... Check>
using	require_any_var_vt = require_any_t< container_type_check_base< is_var, value_type_t, TypeCheck, Check >... >
	Require any of the types satisfy is_var.
template<template< class... > class TypeCheck, class... Check>
using	require_all_var_vt = require_all_t< container_type_check_base< is_var, value_type_t, TypeCheck, Check >... >
	Require all of the types satisfy is_var.
template<typename T >
using	require_not_vt_var = require_not_t< is_var< value_type_t< std::decay_t< T > > > >
	Require value type does not satisfy is_var.
template<typename... Types>
using	require_any_vt_var = require_any_t< is_var< value_type_t< std::decay_t< Types > > >... >
	Require any of the value_types satisfy is_var.
template<typename... Types>
using	require_all_not_vt_var = require_all_not_t< is_var< value_type_t< std::decay_t< Types > > >... >
	Require none of the value_types satisfy is_var.
template<typename T >
using	require_st_var = require_t< is_var< scalar_type_t< std::decay_t< T > > > >
	Require scalar_type satisfies is_var.
template<typename T >
using	require_not_st_var = require_not_t< is_var< scalar_type_t< std::decay_t< T > > > >
	Require scalar type does not satisfy is_var.
template<typename... Types>
using	require_all_st_var = require_all_t< is_var< scalar_type_t< std::decay_t< Types > > >... >
	Require all of the scalar types satisfy is_var.
template<typename... Types>
using	require_any_st_var = require_any_t< is_var< scalar_type_t< std::decay_t< Types > > >... >
	Require any of the scalar types satisfy is_var.
template<typename... Types>
using	require_all_not_st_var = require_all_not_t< is_var< scalar_type_t< std::decay_t< Types > > >... >
	Require none of the scalar types satisfy is_var.
template<typename... Types>
using	is_var_and_matrix_types = bool_constant< is_var< return_type_t< Types... > >::value &&stan::math::disjunction< is_matrix< Types >... >::value >
	Extends std::true_type when instantiated with at least one type that has a var scalar_type and at least one type is a matrix.
template<typename... Types>
using	require_all_not_var_and_matrix_types = require_not_t< is_var_and_matrix_types< Types... > >
template<typename T >
using	require_var_dense_dynamic_t = require_t< is_var_dense_dynamic< std::decay_t< T > > >
	Require type satisfies is_var_dense_dynamic.
template<typename T >
using	require_var_matrix_t = require_t< is_var_matrix< std::decay_t< T > > >
	Require type satisfies is_var_matrix.
template<typename T >
using	require_not_var_matrix_t = require_not_t< is_var_matrix< std::decay_t< T > > >
	Require type does not satisfy is_var_matrix.
template<typename... Types>
using	require_all_var_matrix_t = require_all_t< is_var_matrix< std::decay_t< Types > >... >
	Require all of the types satisfy is_var_matrix.
template<typename... Types>
using	require_any_var_matrix_t = require_any_t< is_var_matrix< std::decay_t< Types > >... >
	Require any of the types satisfy is_var_matrix.
template<typename... Types>
using	require_all_not_var_matrix_t = require_all_not_t< is_var_matrix< std::decay_t< Types > >... >
	Require none of the types satisfy is_var_matrix.
template<typename T >
using	require_var_col_vector_t = require_t< is_var_col_vector< std::decay_t< T > > >
	Require type satisfies is_var_col_vector.
template<typename T >
using	require_not_var_col_vector_t = require_not_t< is_var_col_vector< std::decay_t< T > > >
	Require type does not satisfy is_var_col_vector.
template<typename T >
using	require_var_row_vector_t = require_t< is_var_row_vector< std::decay_t< T > > >
	Require type satisfies is_var_row_vector.
template<typename T >
using	require_var_vector_t = require_t< is_var_vector< std::decay_t< T > > >
	Require type satisfies is_var_vector.
template<typename... Types>
using	require_all_var_vector_t = require_all_t< is_var_vector< std::decay_t< Types > >... >
	Require all of the types satisfy is_var_vector.
template<typename... Types>
using	require_any_var_vector_t = require_any_t< is_var_vector< std::decay_t< Types > >... >
	Require any of the types satisfy is_var_vector.
template<typename... T>
using	is_var_or_arithmetic = math::conjunction< is_var_or_arithmetic_type< T >... >
	Extends std::true_type if all the provided types are either var or an arithmetic type, extends std::false_type otherwise.
template<typename T >
using	require_var_or_arithmetic_t = require_t< is_var_or_arithmetic< std::decay_t< T > > >
	Require type satisfies is_var_or_arithmetic.
template<typename T >
using	require_not_var_or_arithmetic_t = require_not_t< is_var_or_arithmetic< std::decay_t< T > > >
	Require type does not satisfy is_var_or_arithmetic.
template<typename... Types>
using	require_all_var_or_arithmetic_t = require_all_t< is_var_or_arithmetic< std::decay_t< Types > >... >
	Require all of the types satisfy is_var_or_arithmetic.
template<typename... Types>
using	require_any_var_or_arithmetic_t = require_any_t< is_var_or_arithmetic< std::decay_t< Types > >... >
	Require any of the types satisfy is_var_or_arithmetic.
template<typename... Types>
using	require_all_not_var_or_arithmetic_t = require_all_not_t< is_var_or_arithmetic< std::decay_t< Types > >... >
	Require none of the types satisfy is_var_or_arithmetic.
template<typename... Types>
using	require_any_not_var_or_arithmetic_t = require_any_not_t< is_var_or_arithmetic< std::decay_t< Types > >... >
	Require at least one of the types do not satisfy is_var_or_arithmetic.
template<typename... Types>
using	require_all_st_var_or_arithmetic = require_all_t< is_var_or_arithmetic< scalar_type_t< std::decay_t< Types > > >... >
	Require all of the scalar types satisfy is_var_or_arithmetic.
template<typename T >
using	require_eigen_col_vector_t = require_t< is_eigen_col_vector< std::decay_t< T > > >
	Require type satisfies is_eigen_col_vector.
template<typename T >
using	require_not_eigen_col_vector_t = require_not_t< is_eigen_col_vector< std::decay_t< T > > >
	Require type does not satisfy is_eigen_col_vector.
template<typename... Types>
using	require_all_eigen_col_vector_t = require_all_t< is_eigen_col_vector< std::decay_t< Types > >... >
	Require all of the types satisfy is_eigen_col_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_eigen_col_vector_vt = require_t< container_type_check_base< is_eigen_col_vector, value_type_t, TypeCheck, Check... > >
	Require type satisfies is_eigen_col_vector.
template<typename T >
using	require_col_vector_t = require_t< is_col_vector< std::decay_t< T > > >
	Require type satisfies is_col_vector.
template<typename T >
using	require_not_col_vector_t = require_not_t< is_col_vector< std::decay_t< T > > >
	Require type does not satisfy is_col_vector.
template<typename... Types>
using	require_all_col_vector_t = require_all_t< is_col_vector< std::decay_t< Types > >... >
	Require all of the types satisfy is_col_vector.
template<typename T >
using	require_eigen_row_vector_t = require_t< is_eigen_row_vector< std::decay_t< T > > >
	Require type satisfies is_eigen_row_vector.
template<typename T >
using	require_row_vector_t = require_t< is_row_vector< std::decay_t< T > > >
	Require type satisfies is_row_vector.
template<typename T >
using	require_eigen_vector_t = require_t< is_eigen_vector< std::decay_t< T > > >
	Require type satisfies is_eigen_vector.
template<typename T >
using	require_not_eigen_vector_t = require_not_t< is_eigen_vector< std::decay_t< T > > >
	Require type does not satisfy is_eigen_vector.
template<typename... Types>
using	require_all_eigen_vector_t = require_all_t< is_eigen_vector< std::decay_t< Types > >... >
	Require all of the types satisfy is_eigen_vector.
template<typename... Types>
using	require_any_eigen_vector_t = require_any_t< is_eigen_vector< std::decay_t< Types > >... >
	Require any of the types satisfy is_eigen_vector.
template<typename... Types>
using	require_all_not_eigen_vector_t = require_all_not_t< is_eigen_vector< std::decay_t< Types > >... >
	Require none of the types satisfy is_eigen_vector.
template<typename... Types>
using	require_any_not_eigen_vector_t = require_any_not_t< is_eigen_vector< std::decay_t< Types > >... >
	Require at least one of the types do not satisfy is_eigen_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_eigen_vector_vt = require_t< container_type_check_base< is_eigen_vector, value_type_t, TypeCheck, Check... > >
	Require type satisfies is_eigen_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_not_eigen_vector_vt = require_not_t< container_type_check_base< is_eigen_vector, value_type_t, TypeCheck, Check... > >
	Require type does not satisfy is_eigen_vector or.
template<template< class... > class TypeCheck, class... Check>
using	require_any_eigen_vector_vt = require_any_t< container_type_check_base< is_eigen_vector, value_type_t, TypeCheck, Check >... >
	Require any of the types satisfy is_eigen_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_any_not_eigen_vector_vt = require_any_not_t< container_type_check_base< is_eigen_vector, value_type_t, TypeCheck, Check >... >
	Require at least one of the types does not satisfy is_eigen_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_all_eigen_vector_vt = require_all_t< container_type_check_base< is_eigen_vector, value_type_t, TypeCheck, Check >... >
	Require all of the types satisfy is_eigen_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_all_not_eigen_vector_vt = require_all_not_t< container_type_check_base< is_eigen_vector, value_type_t, TypeCheck, Check >... >
	Require none of the types satisfy is_eigen_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_eigen_vector_st = require_t< container_type_check_base< is_eigen_vector, scalar_type_t, TypeCheck, Check... > >
	Require type satisfies is_eigen_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_not_eigen_vector_st = require_not_t< container_type_check_base< is_eigen_vector, scalar_type_t, TypeCheck, Check... > >
	Require type does not satisfy is_eigen_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_any_eigen_vector_st = require_any_t< container_type_check_base< is_eigen_vector, scalar_type_t, TypeCheck, Check >... >
	Require any of the types satisfy is_eigen_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_any_not_eigen_vector_st = require_any_not_t< container_type_check_base< is_eigen_vector, scalar_type_t, TypeCheck, Check >... >
	Require at least one of the types does not satisfy is_eigen_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_all_eigen_vector_st = require_all_t< container_type_check_base< is_eigen_vector, scalar_type_t, TypeCheck, Check >... >
	Require all of the types does not satisfy is_eigen_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_all_not_eigen_vector_st = require_all_not_t< container_type_check_base< is_eigen_vector, scalar_type_t, TypeCheck, Check >... >
	Require none of the types satisfy is_eigen_vector.
template<typename Row , typename Col >
using	require_eigen_row_and_col_t = require_t< math::conjunction< is_eigen_row_vector< Row >, is_eigen_col_vector< Col > > >
	Require Row is a row vector and Col is a column vector.
template<typename Row , typename Col >
using	require_not_eigen_row_and_col_t = require_not_t< math::conjunction< is_eigen_row_vector< Row >, is_eigen_col_vector< Col > > >
	Require Row is not a row vector and Col is not a column vector.
template<typename Row , typename Col >
using	require_row_and_col_vector_t = require_t< math::conjunction< is_row_vector< Row >, is_col_vector< Col > > >
	Require Row is a row vector and Col is a column vector.
template<typename Row , typename Col >
using	require_not_row_and_col_vector_t = require_not_t< math::conjunction< is_row_vector< Row >, is_col_vector< Col > > >
	Require Row is not a row vector and Col is not a column vector.
template<typename T >
using	require_vector_t = require_t< is_vector< std::decay_t< T > > >
	Require type satisfies is_vector.
template<typename T >
using	require_not_vector_t = require_not_t< is_vector< std::decay_t< T > > >
	Require type does not satisfy is_vector.
template<typename... Types>
using	require_all_vector_t = require_all_t< is_vector< std::decay_t< Types > >... >
	Require all of the types satisfy is_vector.
template<typename... Types>
using	require_any_vector_t = require_any_t< is_vector< std::decay_t< Types > >... >
	Require any of the types satisfy is_vector.
template<typename... Types>
using	require_all_not_vector_t = require_all_not_t< is_vector< std::decay_t< Types > >... >
	Require none of the types satisfy is_vector.
template<typename... Types>
using	require_any_not_vector_t = require_any_not_t< is_vector< std::decay_t< Types > >... >
	Require at least one of the types do not satisfy is_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_vector_vt = require_t< container_type_check_base< is_vector, value_type_t, TypeCheck, Check... > >
	Require type satisfies is_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_not_vector_vt = require_not_t< container_type_check_base< is_vector, value_type_t, TypeCheck, Check... > >
	Require type does not satisfy is_vector or.
template<template< class... > class TypeCheck, class... Check>
using	require_any_vector_vt = require_any_t< container_type_check_base< is_vector, value_type_t, TypeCheck, Check >... >
	Require any of the types satisfy is_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_any_not_vector_vt = require_any_not_t< container_type_check_base< is_vector, value_type_t, TypeCheck, Check >... >
	Require at least one of the types does not satisfy is_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_all_vector_vt = require_all_t< container_type_check_base< is_vector, value_type_t, TypeCheck, Check >... >
	Require all of the types satisfy is_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_all_not_vector_vt = require_all_not_t< container_type_check_base< is_vector, value_type_t, TypeCheck, Check >... >
	Require none of the types satisfy is_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_vector_st = require_t< container_type_check_base< is_vector, scalar_type_t, TypeCheck, Check... > >
	Require type satisfies is_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_not_vector_st = require_not_t< container_type_check_base< is_vector, scalar_type_t, TypeCheck, Check... > >
	Require type does not satisfy is_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_any_vector_st = require_any_t< container_type_check_base< is_vector, scalar_type_t, TypeCheck, Check >... >
	Require any of the types satisfy is_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_any_not_vector_st = require_any_not_t< container_type_check_base< is_vector, scalar_type_t, TypeCheck, Check >... >
	Require at least one of the types does not satisfy is_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_all_vector_st = require_all_t< container_type_check_base< is_vector, scalar_type_t, TypeCheck, Check >... >
	Require all of the types does not satisfy is_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_all_not_vector_st = require_all_not_t< container_type_check_base< is_vector, scalar_type_t, TypeCheck, Check >... >
	Require none of the types satisfy is_vector.
template<typename T >
using	require_std_vector_t = require_t< is_std_vector< std::decay_t< T > > >
	Require type satisfies is_std_vector.
template<typename T >
using	require_not_std_vector_t = require_not_t< is_std_vector< std::decay_t< T > > >
	Require type does not satisfy is_std_vector.
template<typename... Types>
using	require_all_std_vector_t = require_all_t< is_std_vector< std::decay_t< Types > >... >
	Require all of the types satisfy is_std_vector.
template<typename... Types>
using	require_any_std_vector_t = require_any_t< is_std_vector< std::decay_t< Types > >... >
	Require any of the types satisfy is_std_vector.
template<typename... Types>
using	require_all_not_std_vector_t = require_all_not_t< is_std_vector< std::decay_t< Types > >... >
	Require none of the types satisfy is_std_vector.
template<typename... Types>
using	require_any_not_std_vector_t = require_any_not_t< is_std_vector< std::decay_t< Types > >... >
	Require at least one of the types do not satisfy is_std_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_std_vector_vt = require_t< container_type_check_base< is_std_vector, value_type_t, TypeCheck, Check... > >
	Require type satisfies is_std_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_not_std_vector_vt = require_not_t< container_type_check_base< is_std_vector, value_type_t, TypeCheck, Check... > >
	Require type does not satisfy is_std_vector or.
template<template< class... > class TypeCheck, class... Check>
using	require_any_std_vector_vt = require_any_t< container_type_check_base< is_std_vector, value_type_t, TypeCheck, Check >... >
	Require any of the types satisfy is_std_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_any_not_std_vector_vt = require_any_not_t< container_type_check_base< is_std_vector, value_type_t, TypeCheck, Check >... >
	Require at least one of the types does not satisfy is_std_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_all_std_vector_vt = require_all_t< container_type_check_base< is_std_vector, value_type_t, TypeCheck, Check >... >
	Require all of the types satisfy is_std_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_all_not_std_vector_vt = require_all_not_t< container_type_check_base< is_std_vector, value_type_t, TypeCheck, Check >... >
	Require none of the types satisfy is_std_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_std_vector_st = require_t< container_type_check_base< is_std_vector, scalar_type_t, TypeCheck, Check... > >
	Require type satisfies is_std_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_not_std_vector_st = require_not_t< container_type_check_base< is_std_vector, scalar_type_t, TypeCheck, Check... > >
	Require type does not satisfy is_std_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_any_std_vector_st = require_any_t< container_type_check_base< is_std_vector, scalar_type_t, TypeCheck, Check >... >
	Require any of the types satisfy is_std_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_any_not_std_vector_st = require_any_not_t< container_type_check_base< is_std_vector, scalar_type_t, TypeCheck, Check >... >
	Require at least one of the types does not satisfy is_std_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_all_std_vector_st = require_all_t< container_type_check_base< is_std_vector, scalar_type_t, TypeCheck, Check >... >
	Require all of the types does not satisfy is_std_vector.
template<template< class... > class TypeCheck, class... Check>
using	require_all_not_std_vector_st = require_all_not_t< container_type_check_base< is_std_vector, scalar_type_t, TypeCheck, Check >... >
	Require none of the types satisfy is_std_vector.
template<typename T >
using	require_vector_like_t = require_t< is_vector_like< std::decay_t< T > > >
	Require type satisfies is_vector_like.
template<typename T >
using	require_not_vector_like_t = require_not_t< is_vector_like< std::decay_t< T > > >
	Require type does not satisfy is_vector_like.
template<typename... Types>
using	require_all_vector_like_t = require_all_t< is_vector_like< std::decay_t< Types > >... >
	Require all of the types satisfy is_vector_like.
template<typename... Types>
using	require_any_vector_like_t = require_any_t< is_vector_like< std::decay_t< Types > >... >
	Require any of the types satisfy is_vector_like.
template<typename... Types>
using	require_all_not_vector_like_t = require_all_not_t< is_vector_like< std::decay_t< Types > >... >
	Require none of the types satisfy is_vector_like.
template<typename... Types>
using	require_any_not_vector_like_t = require_any_not_t< is_vector_like< std::decay_t< Types > >... >
	Require at least one of the types do not satisfy is_vector_like.
template<template< class... > class TypeCheck, class... Check>
using	require_vector_like_vt = require_t< container_type_check_base< is_vector_like, value_type_t, TypeCheck, Check... > >
	Require type satisfies is_vector_like.
template<typename... Args>
using	partials_return_t = typename partials_return_type< Args... >::type
template<typename T >
using	partials_type_t = typename partials_type< T >::type
	Helper alias for accessing the partial type.
template<typename T >
using	plain_type_t = typename plain_type< T >::type
template<typename T >
using	eval_return_type_t = typename eval_return_type< T >::type
template<typename... Args>
using	promote_args_t = typename boost::math::tools::promote_args< Args... >::type
	Convenience alias for boost tools promote_args.
template<typename T >
using	ref_type_t = typename ref_type_if< true, T >::type
template<bool Condition, typename T >
using	ref_type_if_t = typename ref_type_if< Condition, T >::type
template<typename T >
using	ref_type_if_not_constant_t = typename ref_type_if<!is_constant< T >::value, T >::type
template<typename T , typename S >
using	require_same_t = require_t< std::is_same< std::decay_t< T >, std::decay_t< S > > >
	Require types T and S satisfies std::is_same.
template<typename T , typename S >
using	require_not_same_t = require_not_t< std::is_same< std::decay_t< T >, std::decay_t< S > > >
	Require types T and S does not satisfy std::is_same.
template<typename T , typename... Types>
using	require_all_same_t = require_all_t< std::is_same< std::decay_t< T >, std::decay_t< Types > >... >
	Require T and all of the Types satisfy std::is_same.
template<typename T , typename... Types>
using	require_any_same_t = require_any_t< std::is_same< std::decay_t< T >, std::decay_t< Types > >... >
	Require any of the Types and T satisfy std::is_same.
template<typename T , typename... Types>
using	require_all_not_same_t = require_all_not_t< std::is_same< std::decay_t< T >, std::decay_t< Types > >... >
	Require none of the Types and T satisfy std::is_same.
template<typename T , typename... Types>
using	require_any_not_same_t = require_any_not_t< std::is_same< std::decay_t< T >, std::decay_t< Types > >... >
	Any one of the Types and T do not satisfy std::is_same.
template<typename T , typename S >
using	require_st_same = require_t< std::is_same< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > >
	Require that value types of T and S satisfies std::is_same.
template<typename T , typename S >
using	require_not_st_same = require_not_t< std::is_same< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > >
	Require scalar types of T and S does not satisfy std::is_same.
template<typename T , typename... Types>
using	require_all_st_same = require_all_t< std::is_same< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
	All scalar types of T and all of the Types satisfy std::is_same.
template<typename T , typename... Types>
using	require_any_not_st_same = require_any_not_t< std::is_same< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
	Any of the scalar types Types and T do not satisfy std::is_same.
template<typename T , typename S >
using	require_vt_same = require_t< std::is_same< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< S > > > >
	Value types of T and S satisfies std::is_same.
template<typename T , typename... Types>
using	require_all_vt_same = require_all_t< std::is_same< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
	Value types of T and all of the Types satisfy std::is_same.
template<typename T , typename S >
using	require_convertible_t = require_t< std::is_convertible< std::decay_t< T >, std::decay_t< S > > >
	Require types T and S satisfies std::is_convertible.
template<typename T , typename S >
using	require_not_convertible_t = require_not_t< std::is_convertible< std::decay_t< T >, std::decay_t< S > > >
	Require types T and S does not satisfy std::is_convertible.
template<typename T , typename... Types>
using	require_all_convertible_t = require_all_t< std::is_convertible< std::decay_t< T >, std::decay_t< Types > >... >
	Require T and all of the Types satisfy std::is_convertible.
template<typename T , typename... Types>
using	require_any_not_convertible_t = require_any_not_t< std::is_convertible< std::decay_t< T >, std::decay_t< Types > >... >
	Any one of the Types and T do not satisfy.
template<typename T , typename S >
using	require_assignable_t = require_t< std::is_assignable< std::decay_t< T >, std::decay_t< S > > >
	Require types T and S satisfies std::is_assignable.
template<typename T , typename S >
using	require_not_assignable_t = require_not_t< std::is_assignable< std::decay_t< T >, std::decay_t< S > > >
	Require types T and S does not satisfy std::is_assignable.
template<typename T , typename S >
using	require_st_assignable = require_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > >
	Require that value types of T and S satisfies std::is_assignable.
template<typename T , typename S >
using	require_not_st_assignable = require_not_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > >
	Require scalar types of T and S does not satisfy std::is_assignable.
template<typename T , typename... Types>
using	require_all_st_assignable = require_all_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
	All scalar types of T and all of the Types satisfy std::is_assignable.
template<typename T , typename... Types>
using	require_any_st_assignable = require_any_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
	Any of the scalar types of Types and T satisfy std::is_assignable.
template<typename T , typename... Types>
using	require_all_not_st_assignable = require_all_not_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
	None of the scalar types of Types and T satisfy std::is_assignable.
template<typename T , typename... Types>
using	require_any_not_st_assignable = require_any_not_t< std::is_assignable< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
	Any of the scalar types Types and T do not satisfy std::is_assignable.
template<typename T , typename S >
using	require_vt_assignable = require_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< S > > > >
	Value types of T and S satisfies std::is_assignable.
template<typename T , typename S >
using	require_not_vt_assignable = require_not_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< S > > > >
	Value types of T and S does not satisfy std::is_assignable.
template<typename T , typename... Types>
using	require_all_vt_assignable = require_all_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
	Value types of T and all of the Types satisfy std::is_assignable.
template<typename T , typename... Types>
using	require_any_vt_assignable = require_any_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
	Any of the value types of Types and T satisfy std::is_assignable.
template<typename T , typename... Types>
using	require_all_not_vt_assignable = require_all_not_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
	None of the value types of Types and T satisfy std::is_assignable.
template<typename T , typename... Types>
using	require_any_not_vt_assignable = require_any_not_t< std::is_assignable< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
	Any of the value types Types and T do not satisfy std::is_assignable.
template<typename T , typename S >
using	require_constructible_t = require_t< std::is_constructible< std::decay_t< T >, std::decay_t< S > > >
	Require types T and S satisfies std::is_constructible.
template<typename T , typename S >
using	require_st_constructible = require_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > >
	Require that value types of T and S satisfies std::is_constructible.
template<typename T , typename S >
using	require_not_st_constructible = require_not_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< S > > > >
	Require scalar types of T and S does not satisfy std::is_constructible.
template<typename T , typename... Types>
using	require_all_st_constructible = require_all_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
	All scalar types of T and all of the Types satisfy std::is_constructible.
template<typename T , typename... Types>
using	require_any_st_constructible = require_any_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
	Any of the scalar types of Types and T satisfy std::is_constructible.
template<typename T , typename... Types>
using	require_all_not_st_constructible = require_all_not_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
	None of the scalar types of Types and T satisfy std::is_constructible.
template<typename T , typename... Types>
using	require_any_not_st_constructible = require_any_not_t< std::is_constructible< scalar_type_t< std::decay_t< T > >, scalar_type_t< std::decay_t< Types > > >... >
	Any of the scalar types Types and T do not satisfy std::is_constructible.
template<typename T , typename S >
using	require_vt_constructible = require_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< S > > > >
	Value types of T and S satisfies std::is_constructible.
template<typename T , typename S >
using	require_not_vt_constructible = require_not_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< S > > > >
	Value types of T and S does not satisfy std::is_constructible.
template<typename T , typename... Types>
using	require_all_vt_constructible = require_all_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
	Value types of T and all of the Types satisfy std::is_constructible.
template<typename T , typename... Types>
using	require_any_vt_constructible = require_any_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
	Any of the value types of Types and T satisfy std::is_constructible.
template<typename T , typename... Types>
using	require_all_not_vt_constructible = require_all_not_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
	None of the value types of Types and T satisfy std::is_constructible.
template<typename T , typename... Types>
using	require_any_not_vt_constructible = require_any_not_t< std::is_constructible< value_type_t< std::decay_t< T > >, value_type_t< std::decay_t< Types > > >... >
	Any of the value types Types and T do not satisfy std::is_constructible.
template<typename T >
using	require_arithmetic_t = require_t< std::is_arithmetic< std::decay_t< T > > >
	Require type satisfies std::is_arithmetic.
template<typename T >
using	require_not_arithmetic_t = require_not_t< std::is_arithmetic< std::decay_t< T > > >
	Require type does not satisfy std::is_arithmetic.
template<typename... Types>
using	require_all_arithmetic_t = require_all_t< std::is_arithmetic< std::decay_t< Types > >... >
	Require all of the types satisfy std::is_arithmetic.
template<typename... Types>
using	require_any_arithmetic_t = require_any_t< std::is_arithmetic< std::decay_t< Types > >... >
	Require any of the types satisfy std::is_arithmetic.
template<typename... Types>
using	require_all_not_arithmetic_t = require_all_not_t< std::is_arithmetic< std::decay_t< Types > >... >
	Require none of the types satisfy std::is_arithmetic.
template<typename... Types>
using	require_any_not_arithmetic_t = require_any_not_t< std::is_arithmetic< std::decay_t< Types > >... >
	Require at least one of the types do not satisfy std::is_arithmetic.
template<typename... Types>
using	require_all_vt_arithmetic = require_all_t< std::is_arithmetic< value_type_t< std::decay_t< Types > > >... >
	Require all of the value types satisfy std::is_arithmetic.
template<typename... Types>
using	require_any_not_vt_arithmetic = require_any_not_t< std::is_arithmetic< value_type_t< std::decay_t< Types > > >... >
	Require at least one of the value types do not satisfy std::is_arithmetic.
template<typename T >
using	require_st_arithmetic = require_t< std::is_arithmetic< scalar_type_t< std::decay_t< T > > > >
	Require scalar type satisfies std::is_arithmetic.
template<typename T >
using	require_not_st_arithmetic = require_not_t< std::is_arithmetic< scalar_type_t< std::decay_t< T > > > >
	Require scalar type does not satisfy std::is_arithmetic.
template<typename... Types>
using	require_all_st_arithmetic = require_all_t< std::is_arithmetic< scalar_type_t< std::decay_t< Types > > >... >
	Require all of the scalar types satisfy std::is_arithmetic.
template<typename... Types>
using	require_any_st_arithmetic = require_any_t< std::is_arithmetic< scalar_type_t< std::decay_t< Types > > >... >
	Require any of the scalar types satisfy std::is_arithmetic.
template<typename... Types>
using	require_any_not_st_arithmetic = require_any_not_t< std::is_arithmetic< scalar_type_t< std::decay_t< Types > > >... >
	Any of the scalar types do not satisfy std::is_arithmetic.
template<typename T >
using	require_floating_point_t = require_t< std::is_floating_point< std::decay_t< T > > >
	Require type satisfies std::is_floating_point.
template<typename T >
using	require_integral_t = require_t< std::is_integral< std::decay_t< T > > >
	Require type satisfies std::is_integral.
template<typename T >
using	require_vt_integral = require_t< std::is_integral< value_type_t< std::decay_t< T > > > >
	Require value type satisfies std::is_integral.
template<typename T >
using	require_st_integral = require_t< std::is_integral< scalar_type_t< std::decay_t< T > > > >
	Require scalar type satisfies std::is_integral.
template<typename T >
using	require_not_st_integral = require_not_t< std::is_integral< scalar_type_t< std::decay_t< T > > > >
	Require scalar type does not satisfy std::is_integral.
template<typename... Types>
using	require_all_not_st_integral = require_all_not_t< std::is_integral< scalar_type_t< std::decay_t< Types > > >... >
	Require none of the scalar types satisfy std::is_integral.
template<class Check >
using	require_t = std::enable_if_t< Check::value >
	If condition is true, template is enabled.
template<typename Check >
using	require_not_t = std::enable_if_t<!Check::value >
	If condition is false, template is disabled.
template<class... Checks>
using	require_all_t = std::enable_if_t< math::conjunction< Checks... >::value >
	If all conditions are true, template is enabled Returns a type void if all conditions are true and otherwise fails.
template<class... Checks>
using	require_any_t = std::enable_if_t< math::disjunction< Checks... >::value >
	If any condition is true, template is enabled.
template<class... Checks>
using	require_all_not_t = std::enable_if_t<!math::disjunction< Checks... >::value >
	If all conditions are false, template is enabled.
template<class... Checks>
using	require_any_not_t = std::enable_if_t<!math::conjunction< Checks... >::value >
	If any condition is false, template is enabled.
template<template< class... > class ContainerCheck, template< class... > class ValueCheck, template< class... > class TypeCheck, class... Check>
using	container_type_check_base = bool_constant< math::conjunction< ContainerCheck< std::decay_t< Check > >..., TypeCheck< ValueCheck< Check > >... >::value >
	Used as the base for checking whether a type is a container with an underlying scalar type.
template<typename... Ts>
using	real_return_t = typename real_return< Ts... >::type
	Convenience type to calculate the real return type.
template<typename... Ts>
using	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	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	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	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	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	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	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	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... > > >
template<typename T >
using	scalar_type_t = typename scalar_type< T >::type
template<typename T >
using	value_type_t = typename value_type< T >::type
	Helper function for accessing underlying type.
template<typename... Ts>
using	void_t = typename make_void< Ts... >::type
	Utility metafunction that maps a sequence of any types to the type void This metafunction is used in template metaprogramming to detect ill-formed types or the validity of an expression in an SFINAE context:
template<typename T >
using	arena_t = typename internal::arena_type_impl< std::decay_t< T > >::type
	Determines a type that can be used in place of T that does any dynamic allocations on the AD stack.
template<typename T_scalar , typename T_container >
using	conditional_var_value_t = typename conditional_var_value< T_scalar, T_container >::type
template<typename ReturnType , typename... Types>
using	promote_var_matrix_t = std::conditional_t< is_any_var_matrix< ReturnType, Types... >::value, stan::math::var_value< stan::math::promote_scalar_t< double, ReturnType > >, stan::math::promote_scalar_t< stan::math::var_value< double >, ReturnType > >
	Given an Eigen type and several inputs, determine if a matrix should be var<Matrix> or Matrix<var>.
template<typename ReturnType , typename... Types>
using	return_var_matrix_t = std::conditional_t< is_any_var_matrix< ReturnType, Types... >::value, stan::math::var_value< stan::math::promote_scalar_t< double, plain_type_t< ReturnType > > >, stan::math::promote_scalar_t< stan::math::var_value< double >, plain_type_t< ReturnType > > >
	Given an Eigen type and several inputs, determine if a matrix should be var<Matrix> or Matrix<var>.
template<int Rows, int Cols, typename... Inputs>
using	rev_matrix_t = typename rev_matrix_type< Rows, Cols, Inputs... >::type

Functions
template<typename T , typename = require_stan_scalar_t<T>>
T	get (const T &x, size_t n)
	Returns the provided element.
template<typename T >
T	get (const std::vector< T > &x, size_t n)
	Returns the n-th element of the provided std::vector.
template<typename T , typename = require_eigen_t<T>>
scalar_type_t< T >	get (const T &m, size_t n)
	Returns the n-th element of the provided Eigen matrix.

Variables
template<typename T >
constexpr bool	is_real_v = is_real<T>::value