stan::math Namespace Reference

Namespaces
	internal

Classes
class	accumulator
struct	acos_fun
struct	acosh_fun
struct	ad_promotable
struct	ad_promotable< typename boost::enable_if< boost::is_arithmetic< T >, T >::type, T >
struct	ad_promotable< bool, double >
struct	ad_promotable< char, double >
struct	ad_promotable< double, double >
struct	ad_promotable< float, double >
struct	ad_promotable< int, double >
struct	ad_promotable< long double, double >
struct	ad_promotable< long, double >
struct	ad_promotable< short, double >
struct	ad_promotable< T, var >
struct	ad_promotable< unsigned char, double >
struct	ad_promotable< unsigned int, double >
struct	ad_promotable< unsigned long, double >
struct	ad_promotable< unsigned short, double >
struct	ad_promotable< V, fvar< T > >
struct	ad_promotable< var, var >
struct	algebra_solver_vari
struct	append_return_type
struct	append_return_type< Eigen::Matrix< T1, R, C >, Eigen::Matrix< T2, R, C > >
struct	append_return_type< int, int >
struct	append_return_type< std::vector< T1 >, std::vector< T2 > >
struct	apply_scalar_unary
struct	apply_scalar_unary< F, double >
struct	apply_scalar_unary< F, fvar< T > >
struct	apply_scalar_unary< F, int >
struct	apply_scalar_unary< F, std::vector< T > >
struct	apply_scalar_unary< F, var >
class	array_builder
struct	asin_fun
struct	asinh_fun
struct	atan_fun
struct	atanh_fun
struct	AutodiffStackSingleton
struct	cbrt_fun
struct	ceil_fun
class	chainable_alloc
struct	child_type
struct	child_type< T_struct< T_child > >
class	cholesky_block
class	cholesky_scalar
struct	common_type
struct	common_type< Eigen::Matrix< T1, R, C >, Eigen::Matrix< T2, R, C > >
struct	common_type< std::vector< T1 >, std::vector< T2 > >
struct	cos_fun
struct	cosh_fun
struct	coupled_ode_observer
struct	coupled_ode_system
class	coupled_ode_system< F, double, double >
struct	coupled_ode_system< F, double, var >
struct	coupled_ode_system< F, var, double >
struct	coupled_ode_system< F, var, var >
class	cov_exp_quad_vari
class	cov_exp_quad_vari< T_x, double, T_l >
class	cvodes_integrator
class	cvodes_ode_data
struct	digamma_fun
struct	erf_fun
struct	erfc_fun
struct	exp2_fun
struct	exp_fun
struct	expm1_fun
struct	fabs_fun
struct	floor_fun
struct	fvar
class	gevv_vvv_vari
class	gp_periodic_cov_vari
class	gp_periodic_cov_vari< T_x, double, T_l, T_p >
struct	hybrj_functor_solver
struct	include_summand
struct	index_type
struct	index_type< const T >
struct	index_type< Eigen::Matrix< T, R, C > >
struct	index_type< std::vector< T > >
struct	inv_cloglog_fun
struct	inv_fun
struct	inv_logit_fun
struct	inv_Phi_fun
struct	inv_sqrt_fun
struct	inv_square_fun
class	LDLT_alloc
class	LDLT_factor
class	LDLT_factor< var, R, C >
struct	lgamma_fun
struct	log10_fun
struct	log1m_exp_fun
struct	log1m_fun
struct	log1m_inv_logit_fun
struct	log1p_exp_fun
struct	log1p_fun
struct	log2_fun
struct	log_fun
struct	log_inv_logit_fun
struct	logit_fun
class	matrix_exp_action_handler
class	matrix_exp_action_vari
class	matrix_exp_action_vari< double, N, Tb, Cb >
class	matrix_exp_action_vari< Ta, N, double, Cb >
class	multiply_mat_vari
class	multiply_mat_vari< double, 1, Ca, Tb, 1 >
class	multiply_mat_vari< double, Ra, Ca, Tb, Cb >
class	multiply_mat_vari< Ta, 1, Ca, double, 1 >
class	multiply_mat_vari< Ta, 1, Ca, Tb, 1 >
class	multiply_mat_vari< Ta, Ra, Ca, double, Cb >
struct	nlo_functor
class	op_ddv_vari
class	op_dv_vari
class	op_dvd_vari
class	op_dvv_vari
class	op_matrix_vari
class	op_v_vari
class	op_vd_vari
class	op_vdd_vari
class	op_vdv_vari
class	op_vector_vari
class	op_vv_vari
class	op_vvd_vari
class	op_vvv_vari
class	operands_and_partials
class	operands_and_partials< Op1, Op2, Op3, Op4, Op5, fvar< Dx > >
class	operands_and_partials< Op1, Op2, Op3, Op4, Op5, var >
struct	pass_type
struct	pass_type< double >
struct	pass_type< int >
struct	Phi_approx_fun
struct	Phi_fun
class	precomp_v_vari
class	precomp_vv_vari
class	precomp_vvv_vari
class	precomputed_gradients_vari
struct	promote_elements
struct	promote_elements< Eigen::Matrix< T, R, C >, Eigen::Matrix< S, R, C > >
struct	promote_elements< Eigen::Matrix< T, R, C >, Eigen::Matrix< T, R, C > >
struct	promote_elements< std::vector< T >, std::vector< S > >
struct	promote_elements< std::vector< T >, std::vector< T > >
struct	promote_elements< T, T >
struct	promote_scalar_struct
struct	promote_scalar_struct< T, Eigen::Matrix< S, 1,-1 > >
struct	promote_scalar_struct< T, Eigen::Matrix< S,-1, 1 > >
struct	promote_scalar_struct< T, Eigen::Matrix< S,-1,-1 > >
struct	promote_scalar_struct< T, std::vector< S > >
struct	promote_scalar_struct< T, T >
struct	promote_scalar_type
struct	promote_scalar_type< T, Eigen::Matrix< S, Eigen::Dynamic, Eigen::Dynamic > >
struct	promote_scalar_type< T, Eigen::Matrix< S, 1, Eigen::Dynamic > >
struct	promote_scalar_type< T, Eigen::Matrix< S, Eigen::Dynamic, 1 > >
struct	promote_scalar_type< T, std::vector< S > >
struct	round_fun
class	scal_squared_distance_dv_vari
class	scal_squared_distance_vd_vari
class	scal_squared_distance_vv_vari
class	seq_view
class	seq_view< double, std::vector< int > >
class	seq_view< T, Eigen::Matrix< S, 1, Eigen::Dynamic > >
class	seq_view< T, Eigen::Matrix< S, Eigen::Dynamic, 1 > >
class	seq_view< T, Eigen::Matrix< S, Eigen::Dynamic, Eigen::Dynamic > >
class	seq_view< T, std::vector< S > >
class	seq_view< T, std::vector< std::vector< T > > >
class	seq_view< T, std::vector< T > >
struct	sin_fun
struct	sinh_fun
struct	sqrt_fun
struct	square_fun
class	stack_alloc
struct	store_type
struct	store_type< double >
struct	store_type< int >
class	stored_gradient_vari
class	sum_eigen_v_vari
class	sum_v_vari
struct	system_functor
struct	tan_fun
struct	tanh_fun
struct	tgamma_fun
struct	trigamma_fun
struct	trunc_fun
struct	value_type
struct	value_type< const T >
struct	value_type< Eigen::Matrix< T, R, C > >
struct	value_type< std::vector< T > >
class	var
class	vari
class	welford_covar_estimator
class	welford_var_estimator

Typedefs
typedef Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic >::Index	size_type
typedef Eigen::Matrix< fvar< double >, Eigen::Dynamic, Eigen::Dynamic >	matrix_fd
typedef Eigen::Matrix< fvar< fvar< double > >, Eigen::Dynamic, Eigen::Dynamic >	matrix_ffd
typedef Eigen::Matrix< fvar< double >, Eigen::Dynamic, 1 >	vector_fd
typedef Eigen::Matrix< fvar< fvar< double > >, Eigen::Dynamic, 1 >	vector_ffd
typedef Eigen::Matrix< fvar< double >, 1, Eigen::Dynamic >	row_vector_fd
typedef Eigen::Matrix< fvar< fvar< double > >, 1, Eigen::Dynamic >	row_vector_ffd
typedef Eigen::Matrix< fvar< var >, Eigen::Dynamic, Eigen::Dynamic >	matrix_fv
typedef Eigen::Matrix< fvar< fvar< var > >, Eigen::Dynamic, Eigen::Dynamic >	matrix_ffv
typedef Eigen::Matrix< fvar< var >, Eigen::Dynamic, 1 >	vector_fv
typedef Eigen::Matrix< fvar< fvar< var > >, Eigen::Dynamic, 1 >	vector_ffv
typedef Eigen::Matrix< fvar< var >, 1, Eigen::Dynamic >	row_vector_fv
typedef Eigen::Matrix< fvar< fvar< var > >, 1, Eigen::Dynamic >	row_vector_ffv
typedef Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic >	matrix_d
typedef Eigen::Matrix< double, Eigen::Dynamic, 1 >	vector_d
typedef Eigen::Matrix< double, 1, Eigen::Dynamic >	row_vector_d
typedef boost::math::policies::policy< boost::math::policies::overflow_error< boost::math::policies::errno_on_error >, boost::math::policies::pole_error< boost::math::policies::errno_on_error > >	boost_policy_t
typedef AutodiffStackSingleton< vari, chainable_alloc >	ChainableStack
typedef Eigen::Matrix< var, Eigen::Dynamic, Eigen::Dynamic >	matrix_v
typedef Eigen::Matrix< var, Eigen::Dynamic, 1 >	vector_v
typedef Eigen::Matrix< var, 1, Eigen::Dynamic >	row_vector_v

Functions
template<typename T >
fvar< T >	log_sum_exp (const std::vector< fvar< T > > &v)
template<typename T >
fvar< T >	sum (const std::vector< fvar< T > > &m)
template<typename T >
std::vector< fvar< T > >	to_fvar (const std::vector< T > &v)
template<typename T >
std::vector< fvar< T > >	to_fvar (const std::vector< T > &v, const std::vector< T > &d)
template<typename T >
std::vector< fvar< T > >	to_fvar (const std::vector< fvar< T > > &v)
template<typename T >
fvar< T >	operator+ (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	operator+ (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	operator+ (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	operator/ (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	operator/ (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	operator/ (double x1, const fvar< T > &x2)
template<typename T >
bool	operator== (const fvar< T > &x, const fvar< T > &y)
template<typename T >
bool	operator== (const fvar< T > &x, double y)
template<typename T >
bool	operator== (double x, const fvar< T > &y)
template<typename T >
bool	operator> (const fvar< T > &x, const fvar< T > &y)
template<typename T >
bool	operator> (const fvar< T > &x, double y)
template<typename T >
bool	operator> (double x, const fvar< T > &y)
template<typename T >
bool	operator>= (const fvar< T > &x, const fvar< T > &y)
template<typename T >
bool	operator>= (const fvar< T > &x, double y)
template<typename T >
bool	operator>= (double x, const fvar< T > &y)
template<typename T >
bool	operator< (const fvar< T > &x, const fvar< T > &y)
template<typename T >
bool	operator< (double x, const fvar< T > &y)
template<typename T >
bool	operator< (const fvar< T > &x, double y)
template<typename T >
bool	operator<= (const fvar< T > &x, const fvar< T > &y)
template<typename T >
bool	operator<= (const fvar< T > &x, double y)
template<typename T >
bool	operator<= (double x, const fvar< T > &y)
template<typename T >
bool	operator&& (const fvar< T > &x, const fvar< T > &y)
template<typename T >
bool	operator&& (const fvar< T > &x, double y)
template<typename T >
bool	operator&& (double x, const fvar< T > &y)
template<typename T >
bool	operator|| (const fvar< T > &x, const fvar< T > &y)
template<typename T >
bool	operator|| (const fvar< T > &x, double y)
template<typename T >
bool	operator|| (double x, const fvar< T > &y)
template<typename T >
fvar< T >	operator* (const fvar< T > &x, const fvar< T > &y)
template<typename T >
fvar< T >	operator* (double x, const fvar< T > &y)
template<typename T >
fvar< T >	operator* (const fvar< T > &x, double y)
template<typename T >
bool	operator!= (const fvar< T > &x, const fvar< T > &y)
template<typename T >
bool	operator!= (const fvar< T > &x, double y)
template<typename T >
bool	operator!= (double x, const fvar< T > &y)
template<typename T >
fvar< T >	operator- (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	operator- (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	operator- (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	operator- (const fvar< T > &x)
template<typename T >
bool	operator! (const fvar< T > &x)
template<typename T >
fvar< T >	operator+ (const fvar< T > &x)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, 1, C1 >	columns_dot_product (const Eigen::Matrix< fvar< T >, R1, C1 > &v1, const Eigen::Matrix< fvar< T >, R2, C2 > &v2)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, 1, C1 >	columns_dot_product (const Eigen::Matrix< fvar< T >, R1, C1 > &v1, const Eigen::Matrix< double, R2, C2 > &v2)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, 1, C1 >	columns_dot_product (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< fvar< T >, R2, C2 > &v2)
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, 1, C >	columns_dot_self (const Eigen::Matrix< fvar< T >, R, C > &x)
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, C, C >	crossprod (const Eigen::Matrix< fvar< T >, R, C > &m)
template<typename T , int R, int C>
fvar< T >	determinant (const Eigen::Matrix< fvar< T >, R, C > &m)
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, C >	divide (const Eigen::Matrix< fvar< T >, R, C > &v, const fvar< T > &c)
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, C >	divide (const Eigen::Matrix< fvar< T >, R, C > &v, double c)
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, C >	divide (const Eigen::Matrix< double, R, C > &v, const fvar< T > &c)
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, C >	operator/ (const Eigen::Matrix< fvar< T >, R, C > &v, const fvar< T > &c)
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, C >	operator/ (const Eigen::Matrix< fvar< T >, R, C > &v, double c)
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, C >	operator/ (const Eigen::Matrix< double, R, C > &v, const fvar< T > &c)
template<typename T , int R1, int C1, int R2, int C2>
fvar< T >	dot_product (const Eigen::Matrix< fvar< T >, R1, C1 > &v1, const Eigen::Matrix< fvar< T >, R2, C2 > &v2)
template<typename T , int R1, int C1, int R2, int C2>
fvar< T >	dot_product (const Eigen::Matrix< fvar< T >, R1, C1 > &v1, const Eigen::Matrix< double, R2, C2 > &v2)
template<typename T , int R1, int C1, int R2, int C2>
fvar< T >	dot_product (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< fvar< T >, R2, C2 > &v2)
template<typename T , int R1, int C1, int R2, int C2>
fvar< T >	dot_product (const Eigen::Matrix< fvar< T >, R1, C1 > &v1, const Eigen::Matrix< fvar< T >, R2, C2 > &v2, size_type &length)
template<typename T , int R1, int C1, int R2, int C2>
fvar< T >	dot_product (const Eigen::Matrix< fvar< T >, R1, C1 > &v1, const Eigen::Matrix< double, R2, C2 > &v2, size_type &length)
template<typename T , int R1, int C1, int R2, int C2>
fvar< T >	dot_product (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< fvar< T >, R2, C2 > &v2, size_type &length)
template<typename T >
fvar< T >	dot_product (const std::vector< fvar< T > > &v1, const std::vector< fvar< T > > &v2)
template<typename T >
fvar< T >	dot_product (const std::vector< double > &v1, const std::vector< fvar< T > > &v2)
template<typename T >
fvar< T >	dot_product (const std::vector< fvar< T > > &v1, const std::vector< double > &v2)
template<typename T >
fvar< T >	dot_product (const std::vector< fvar< T > > &v1, const std::vector< fvar< T > > &v2, size_type &length)
template<typename T >
fvar< T >	dot_product (const std::vector< double > &v1, const std::vector< fvar< T > > &v2, size_type &length)
template<typename T >
fvar< T >	dot_product (const std::vector< fvar< T > > &v1, const std::vector< double > &v2, size_type &length)
template<typename T , int R, int C>
fvar< T >	dot_self (const Eigen::Matrix< fvar< T >, R, C > &v)
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, C >	inverse (const Eigen::Matrix< fvar< T >, R, C > &m)
template<typename T , int R, int C>
fvar< T >	log_determinant (const Eigen::Matrix< fvar< T >, R, C > &m)
template<typename T >
Eigen::Matrix< fvar< T >, Eigen::Dynamic, 1 >	log_softmax (const Eigen::Matrix< fvar< T >, Eigen::Dynamic, 1 > &alpha)
template<typename T , int R, int C>
fvar< T >	log_sum_exp (const Eigen::Matrix< fvar< T >, R, C > &v)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, C2 >	mdivide_left (const Eigen::Matrix< fvar< T >, R1, C1 > &A, const Eigen::Matrix< fvar< T >, R2, C2 > &b)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, C2 >	mdivide_left (const Eigen::Matrix< double, R1, C1 > &A, const Eigen::Matrix< fvar< T >, R2, C2 > &b)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, C2 >	mdivide_left (const Eigen::Matrix< fvar< T >, R1, C1 > &A, const Eigen::Matrix< double, R2, C2 > &b)
template<int R1, int C1, int R2, int C2, typename T2 >
Eigen::Matrix< fvar< T2 >, R1, C2 >	mdivide_left_ldlt (const LDLT_factor< double, R1, C1 > &A, const Eigen::Matrix< fvar< T2 >, R2, C2 > &b)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, C1 >	mdivide_left_tri_low (const Eigen::Matrix< fvar< T >, R1, C1 > &A, const Eigen::Matrix< fvar< T >, R2, C2 > &b)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, C1 >	mdivide_left_tri_low (const Eigen::Matrix< double, R1, C1 > &A, const Eigen::Matrix< fvar< T >, R2, C2 > &b)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, C1 >	mdivide_left_tri_low (const Eigen::Matrix< fvar< T >, R1, C1 > &A, const Eigen::Matrix< double, R2, C2 > &b)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, C2 >	mdivide_right (const Eigen::Matrix< fvar< T >, R1, C1 > &A, const Eigen::Matrix< fvar< T >, R2, C2 > &b)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, C2 >	mdivide_right (const Eigen::Matrix< fvar< T >, R1, C1 > &A, const Eigen::Matrix< double, R2, C2 > &b)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, C2 >	mdivide_right (const Eigen::Matrix< double, R1, C1 > &A, const Eigen::Matrix< fvar< T >, R2, C2 > &b)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, C1 >	mdivide_right_tri_low (const Eigen::Matrix< fvar< T >, R1, C1 > &A, const Eigen::Matrix< fvar< T >, R2, C2 > &b)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, C2 >	mdivide_right_tri_low (const Eigen::Matrix< fvar< T >, R1, C1 > &A, const Eigen::Matrix< double, R2, C2 > &b)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, C2 >	mdivide_right_tri_low (const Eigen::Matrix< double, R1, C1 > &A, const Eigen::Matrix< fvar< T >, R2, C2 > &b)
template<typename T , int R1, int C1>
Eigen::Matrix< fvar< T >, R1, C1 >	multiply (const Eigen::Matrix< fvar< T >, R1, C1 > &m, const fvar< T > &c)
template<typename T , int R2, int C2>
Eigen::Matrix< fvar< T >, R2, C2 >	multiply (const Eigen::Matrix< fvar< T >, R2, C2 > &m, double c)
template<typename T , int R1, int C1>
Eigen::Matrix< fvar< T >, R1, C1 >	multiply (const Eigen::Matrix< double, R1, C1 > &m, const fvar< T > &c)
template<typename T , int R1, int C1>
Eigen::Matrix< fvar< T >, R1, C1 >	multiply (const fvar< T > &c, const Eigen::Matrix< fvar< T >, R1, C1 > &m)
template<typename T , int R1, int C1>
Eigen::Matrix< fvar< T >, R1, C1 >	multiply (double c, const Eigen::Matrix< fvar< T >, R1, C1 > &m)
template<typename T , int R1, int C1>
Eigen::Matrix< fvar< T >, R1, C1 >	multiply (const fvar< T > &c, const Eigen::Matrix< double, R1, C1 > &m)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, C2 >	multiply (const Eigen::Matrix< fvar< T >, R1, C1 > &m1, const Eigen::Matrix< fvar< T >, R2, C2 > &m2)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, C2 >	multiply (const Eigen::Matrix< fvar< T >, R1, C1 > &m1, const Eigen::Matrix< double, R2, C2 > &m2)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, C2 >	multiply (const Eigen::Matrix< double, R1, C1 > &m1, const Eigen::Matrix< fvar< T >, R2, C2 > &m2)
template<typename T , int C1, int R2>
fvar< T >	multiply (const Eigen::Matrix< fvar< T >, 1, C1 > &rv, const Eigen::Matrix< fvar< T >, R2, 1 > &v)
template<typename T , int C1, int R2>
fvar< T >	multiply (const Eigen::Matrix< fvar< T >, 1, C1 > &rv, const Eigen::Matrix< double, R2, 1 > &v)
template<typename T , int C1, int R2>
fvar< T >	multiply (const Eigen::Matrix< double, 1, C1 > &rv, const Eigen::Matrix< fvar< T >, R2, 1 > &v)
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, R >	multiply_lower_tri_self_transpose (const Eigen::Matrix< fvar< T >, R, C > &m)
template<typename T >
Eigen::Matrix< fvar< T >, Eigen::Dynamic, Eigen::Dynamic >	qr_Q (const Eigen::Matrix< fvar< T >, Eigen::Dynamic, Eigen::Dynamic > &m)
template<typename T >
Eigen::Matrix< fvar< T >, Eigen::Dynamic, Eigen::Dynamic >	qr_R (const Eigen::Matrix< fvar< T >, Eigen::Dynamic, Eigen::Dynamic > &m)
template<int RA, int CA, int RB, int CB, typename T >
Eigen::Matrix< fvar< T >, CB, CB >	quad_form_sym (const Eigen::Matrix< fvar< T >, RA, CA > &A, const Eigen::Matrix< double, RB, CB > &B)
template<int RA, int CA, int RB, typename T >
fvar< T >	quad_form_sym (const Eigen::Matrix< fvar< T >, RA, CA > &A, const Eigen::Matrix< double, RB, 1 > &B)
template<int RA, int CA, int RB, int CB, typename T >
Eigen::Matrix< fvar< T >, CB, CB >	quad_form_sym (const Eigen::Matrix< double, RA, CA > &A, const Eigen::Matrix< fvar< T >, RB, CB > &B)
template<int RA, int CA, int RB, typename T >
fvar< T >	quad_form_sym (const Eigen::Matrix< double, RA, CA > &A, const Eigen::Matrix< fvar< T >, RB, 1 > &B)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, 1 >	rows_dot_product (const Eigen::Matrix< fvar< T >, R1, C1 > &v1, const Eigen::Matrix< fvar< T >, R2, C2 > &v2)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, 1 >	rows_dot_product (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< fvar< T >, R2, C2 > &v2)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< fvar< T >, R1, 1 >	rows_dot_product (const Eigen::Matrix< fvar< T >, R1, C1 > &v1, const Eigen::Matrix< double, R2, C2 > &v2)
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, 1 >	rows_dot_self (const Eigen::Matrix< fvar< T >, R, C > &x)
template<typename T >
Eigen::Matrix< fvar< T >, Eigen::Dynamic, 1 >	softmax (const Eigen::Matrix< fvar< T >, Eigen::Dynamic, 1 > &alpha)
template<typename T , int R, int C>
fvar< T >	squared_distance (const Eigen::Matrix< fvar< T >, R, C > &v1, const Eigen::Matrix< double, R, C > &v2)
template<typename T , int R1, int C1, int R2, int C2>
fvar< T >	squared_distance (const Eigen::Matrix< fvar< T >, R1, C1 > &v1, const Eigen::Matrix< double, R2, C2 > &v2)
template<typename T , int R, int C>
fvar< T >	squared_distance (const Eigen::Matrix< double, R, C > &v1, const Eigen::Matrix< fvar< T >, R, C > &v2)
template<typename T , int R1, int C1, int R2, int C2>
fvar< T >	squared_distance (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< fvar< T >, R2, C2 > &v2)
template<typename T , int R, int C>
fvar< T >	squared_distance (const Eigen::Matrix< fvar< T >, R, C > &v1, const Eigen::Matrix< fvar< T >, R, C > &v2)
template<typename T , int R1, int C1, int R2, int C2>
fvar< T >	squared_distance (const Eigen::Matrix< fvar< T >, R1, C1 > &v1, const Eigen::Matrix< fvar< T >, R2, C2 > &v2)
template<typename T , int R, int C>
fvar< T >	sum (const Eigen::Matrix< fvar< T >, R, C > &m)
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, R >	tcrossprod (const Eigen::Matrix< fvar< T >, R, C > &m)
template<int R, int C, typename T >
Eigen::Matrix< T, R, C >	to_fvar (const Eigen::Matrix< T, R, C > &m)
template<int R, int C>
Eigen::Matrix< fvar< double >, R, C >	to_fvar (const Eigen::Matrix< double, R, C > &m)
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, C >	to_fvar (const Eigen::Matrix< T, R, C > &val, const Eigen::Matrix< T, R, C > &deriv)
template<int RD, int CD, int RA, int CA, int RB, int CB, typename T >
fvar< T >	trace_gen_quad_form (const Eigen::Matrix< fvar< T >, RD, CD > &D, const Eigen::Matrix< fvar< T >, RA, CA > &A, const Eigen::Matrix< fvar< T >, RB, CB > &B)
template<int RA, int CA, int RB, int CB, typename T >
fvar< T >	trace_quad_form (const Eigen::Matrix< fvar< T >, RA, CA > &A, const Eigen::Matrix< fvar< T >, RB, CB > &B)
template<int RA, int CA, int RB, int CB, typename T >
fvar< T >	trace_quad_form (const Eigen::Matrix< fvar< T >, RA, CA > &A, const Eigen::Matrix< double, RB, CB > &B)
template<int RA, int CA, int RB, int CB, typename T >
fvar< T >	trace_quad_form (const Eigen::Matrix< double, RA, CA > &A, const Eigen::Matrix< fvar< T >, RB, CB > &B)
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, C >	unit_vector_constrain (const Eigen::Matrix< fvar< T >, R, C > &y)
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, C >	unit_vector_constrain (const Eigen::Matrix< fvar< T >, R, C > &y, fvar< T > &lp)
template<typename T , typename F >
void	gradient (const F &f, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, T &fx, Eigen::Matrix< T, Eigen::Dynamic, 1 > &grad_fx)
template<typename T , typename F >
void	hessian (const F &f, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, T &fx, Eigen::Matrix< T, Eigen::Dynamic, 1 > &grad, Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &H)
template<typename T , typename F >
void	jacobian (const F &f, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, Eigen::Matrix< T, Eigen::Dynamic, 1 > &fx, Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &J)
template<typename T >
fvar< T >	abs (const fvar< T > &x)
template<typename T >
fvar< T >	acos (const fvar< T > &x)
template<typename T >
fvar< T >	acosh (const fvar< T > &x)
template<typename T >
fvar< T >	asin (const fvar< T > &x)
template<typename T >
fvar< T >	asinh (const fvar< T > &x)
template<typename T >
fvar< T >	atan (const fvar< T > &x)
template<typename T >
fvar< T >	atan2 (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	atan2 (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	atan2 (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	atanh (const fvar< T > &x)
template<typename T >
fvar< T >	bessel_first_kind (int v, const fvar< T > &z)
template<typename T >
fvar< T >	bessel_second_kind (int v, const fvar< T > &z)
template<typename T >
fvar< T >	binary_log_loss (int y, const fvar< T > &y_hat)
template<typename T >
fvar< T >	binomial_coefficient_log (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	binomial_coefficient_log (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	binomial_coefficient_log (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	cbrt (const fvar< T > &x)
template<typename T >
fvar< T >	ceil (const fvar< T > &x)
template<typename T >
fvar< T >	cos (const fvar< T > &x)
template<typename T >
fvar< T >	cosh (const fvar< T > &x)
template<typename T >
fvar< T >	digamma (const fvar< T > &x)
template<typename T >
fvar< T >	erf (const fvar< T > &x)
template<typename T >
fvar< T >	erfc (const fvar< T > &x)
template<typename T >
fvar< T >	exp (const fvar< T > &x)
template<typename T >
fvar< T >	exp2 (const fvar< T > &x)
template<typename T >
fvar< T >	expm1 (const fvar< T > &x)
template<typename T >
fvar< T >	fabs (const fvar< T > &x)
template<typename T >
fvar< T >	falling_factorial (const fvar< T > &x, int n)
template<typename T >
fvar< T >	fdim (const fvar< T > &x, const fvar< T > &y)
template<typename T >
fvar< T >	fdim (const fvar< T > &x, double y)
template<typename T >
fvar< T >	fdim (double x, const fvar< T > &y)
template<typename T >
fvar< T >	floor (const fvar< T > &x)
template<typename T1 , typename T2 , typename T3 >
fvar< typename stan::return_type< T1, T2, T3 >::type >	fma (const fvar< T1 > &x1, const fvar< T2 > &x2, const fvar< T3 > &x3)
template<typename T1 , typename T2 , typename T3 >
fvar< typename stan::return_type< T1, T2, T3 >::type >	fma (const T1 &x1, const fvar< T2 > &x2, const fvar< T3 > &x3)
template<typename T1 , typename T2 , typename T3 >
fvar< typename stan::return_type< T1, T2, T3 >::type >	fma (const fvar< T1 > &x1, const T2 &x2, const fvar< T3 > &x3)
template<typename T1 , typename T2 , typename T3 >
fvar< typename stan::return_type< T1, T2, T3 >::type >	fma (const fvar< T1 > &x1, const fvar< T2 > &x2, const T3 &x3)
template<typename T1 , typename T2 , typename T3 >
fvar< typename stan::return_type< T1, T2, T3 >::type >	fma (const T1 &x1, const T2 &x2, const fvar< T3 > &x3)
template<typename T1 , typename T2 , typename T3 >
fvar< typename stan::return_type< T1, T2, T3 >::type >	fma (const fvar< T1 > &x1, const T2 &x2, const T3 &x3)
template<typename T1 , typename T2 , typename T3 >
fvar< typename stan::return_type< T1, T2, T3 >::type >	fma (const T1 &x1, const fvar< T2 > &x2, const T3 &x3)
template<typename T >
fvar< T >	fmax (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	fmax (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	fmax (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	fmin (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	fmin (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	fmin (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	fmod (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	fmod (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	fmod (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	gamma_p (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	gamma_p (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	gamma_p (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	gamma_q (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	gamma_q (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	gamma_q (double x1, const fvar< T > &x2)
template<typename T >
void	grad_inc_beta (fvar< T > &g1, fvar< T > &g2, fvar< T > a, fvar< T > b, fvar< T > z)
template<typename T >
fvar< T >	hypot (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	hypot (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	hypot (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	inc_beta (const fvar< T > &a, const fvar< T > &b, const fvar< T > &x)
template<typename T >
fvar< T >	inv (const fvar< T > &x)
template<typename T >
fvar< T >	inv_cloglog (const fvar< T > &x)
template<typename T >
fvar< T >	inv_logit (const fvar< T > &x)
template<typename T >
fvar< T >	inv_Phi (const fvar< T > &p)
template<typename T >
fvar< T >	inv_sqrt (const fvar< T > &x)
template<typename T >
fvar< T >	inv_square (const fvar< T > &x)
template<typename T >
int	is_inf (const fvar< T > &x)
template<typename T >
int	is_nan (const fvar< T > &x)
template<typename T >
fvar< T >	lbeta (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	lbeta (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	lbeta (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	lgamma (const fvar< T > &x)
template<typename T >
fvar< typename stan::return_type< T, int >::type >	lmgamma (int x1, const fvar< T > &x2)
template<typename T >
fvar< T >	log (const fvar< T > &x)
template<typename T >
fvar< T >	log10 (const fvar< T > &x)
template<typename T >
fvar< T >	log1m (const fvar< T > &x)
template<typename T >
fvar< T >	log1m_exp (const fvar< T > &x)
template<typename T >
fvar< T >	log1m_inv_logit (const fvar< T > &x)
template<typename T >
fvar< T >	log1p (const fvar< T > &x)
template<typename T >
fvar< T >	log1p_exp (const fvar< T > &x)
template<typename T >
fvar< T >	log2 (const fvar< T > &x)
template<typename T >
fvar< T >	log_diff_exp (const fvar< T > &x1, const fvar< T > &x2)
template<typename T1 , typename T2 >
fvar< T2 >	log_diff_exp (const T1 &x1, const fvar< T2 > &x2)
template<typename T1 , typename T2 >
fvar< T1 >	log_diff_exp (const fvar< T1 > &x1, const T2 &x2)
template<typename T >
fvar< T >	log_falling_factorial (const fvar< T > &x, const fvar< T > &n)
template<typename T >
fvar< T >	log_falling_factorial (double x, const fvar< T > &n)
template<typename T >
fvar< T >	log_falling_factorial (const fvar< T > &x, double n)
template<typename T >
fvar< T >	log_inv_logit (const fvar< T > &x)
template<typename T >
fvar< T >	log_inv_logit_diff (const fvar< T > &x, const fvar< T > &y)
template<typename T >
fvar< T >	log_inv_logit_diff (const fvar< T > &x, double y)
template<typename T >
fvar< T >	log_inv_logit_diff (double x, const fvar< T > &y)
template<typename T_theta , typename T_lambda1 , typename T_lambda2 , int N>
void	log_mix_partial_helper (const T_theta &theta, const T_lambda1 &lambda1, const T_lambda2 &lambda2, typename boost::math::tools::promote_args< T_theta, T_lambda1, T_lambda2 >::type(&partials_array)[N])
template<typename T >
fvar< T >	log_mix (const fvar< T > &theta, const fvar< T > &lambda1, const fvar< T > &lambda2)
template<typename T >
fvar< T >	log_mix (const fvar< T > &theta, const fvar< T > &lambda1, double lambda2)
template<typename T >
fvar< T >	log_mix (const fvar< T > &theta, double lambda1, const fvar< T > &lambda2)
template<typename T >
fvar< T >	log_mix (double theta, const fvar< T > &lambda1, const fvar< T > &lambda2)
template<typename T >
fvar< T >	log_mix (const fvar< T > &theta, double lambda1, double lambda2)
template<typename T >
fvar< T >	log_mix (double theta, const fvar< T > &lambda1, double lambda2)
template<typename T >
fvar< T >	log_mix (double theta, double lambda1, const fvar< T > &lambda2)
template<typename T >
fvar< T >	log_rising_factorial (const fvar< T > &x, const fvar< T > &n)
template<typename T >
fvar< T >	log_rising_factorial (const fvar< T > &x, double n)
template<typename T >
fvar< T >	log_rising_factorial (double x, const fvar< T > &n)
template<typename T >
fvar< T >	log_sum_exp (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	log_sum_exp (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	log_sum_exp (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	logit (const fvar< T > &x)
template<typename T >
fvar< T >	modified_bessel_first_kind (int v, const fvar< T > &z)
template<typename T >
fvar< T >	modified_bessel_second_kind (int v, const fvar< T > &z)
template<typename T >
fvar< T >	multiply_log (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	multiply_log (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	multiply_log (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	owens_t (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	owens_t (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	owens_t (const fvar< T > &x1, double x2)
template<typename T >
fvar< T >	Phi (const fvar< T > &x)
template<typename T >
fvar< T >	Phi_approx (const fvar< T > &x)
template<typename T >
fvar< T >	pow (const fvar< T > &x1, const fvar< T > &x2)
template<typename T >
fvar< T >	pow (double x1, const fvar< T > &x2)
template<typename T >
fvar< T >	pow (const fvar< T > &x1, double x2)
template<typename T >
double	primitive_value (const fvar< T > &v)
template<typename T >
fvar< T >	rising_factorial (const fvar< T > &x, int n)
template<typename T >
fvar< T >	round (const fvar< T > &x)
template<typename T >
fvar< T >	sin (const fvar< T > &x)
template<typename T >
fvar< T >	sinh (const fvar< T > &x)
template<typename T >
fvar< T >	sqrt (const fvar< T > &x)
template<typename T >
fvar< T >	square (const fvar< T > &x)
template<typename T >
fvar< T >	tan (const fvar< T > &x)
template<typename T >
fvar< T >	tanh (const fvar< T > &x)
template<typename T >
fvar< T >	tgamma (const fvar< T > &x)
template<typename T >
fvar< T >	to_fvar (const T &x)
template<typename T >
fvar< T >	to_fvar (const fvar< T > &x)
template<typename T >
fvar< T >	trigamma (const fvar< T > &u)
template<typename T >
fvar< T >	trunc (const fvar< T > &x)
template<typename T >
T	value_of (const fvar< T > &v)
template<typename T >
double	value_of_rec (const fvar< T > &v)
template<typename T >
bool	is_aligned (T *ptr, unsigned int bytes_aligned)
template<typename T , typename F >
void	derivative (const F &f, const T &x, T &fx, T &dfx_dx)
template<typename F >
void	finite_diff_grad_hessian (const F &f, const Eigen::Matrix< double,-1, 1 > &x, double &fx, Eigen::Matrix< double,-1,-1 > &hess, std::vector< Eigen::Matrix< double,-1,-1 > > &grad_hess_fx, double epsilon=1e-04)
template<typename F >
void	grad_hessian (const F &f, const Eigen::Matrix< double, Eigen::Dynamic, 1 > &x, double &fx, Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > &H, std::vector< Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > > &grad_H)
template<typename F >
void	grad_tr_mat_times_hessian (const F &f, const Eigen::Matrix< double, Eigen::Dynamic, 1 > &x, const Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > &M, Eigen::Matrix< double, Eigen::Dynamic, 1 > &grad_tr_MH)
template<typename T1 , typename T2 , typename F >
void	gradient_dot_vector (const F &f, const Eigen::Matrix< T1, Eigen::Dynamic, 1 > &x, const Eigen::Matrix< T2, Eigen::Dynamic, 1 > &v, T1 &fx, T1 &grad_fx_dot_v)
template<typename F >
void	hessian (const F &f, const Eigen::Matrix< double, Eigen::Dynamic, 1 > &x, double &fx, Eigen::Matrix< double, Eigen::Dynamic, 1 > &grad, Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > &H)
template<typename F >
void	hessian_times_vector (const F &f, const Eigen::Matrix< double, Eigen::Dynamic, 1 > &x, const Eigen::Matrix< double, Eigen::Dynamic, 1 > &v, double &fx, Eigen::Matrix< double, Eigen::Dynamic, 1 > &Hv)
template<typename T , typename F >
void	hessian_times_vector (const F &f, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &v, T &fx, Eigen::Matrix< T, Eigen::Dynamic, 1 > &Hv)
template<typename T , typename F >
void	partial_derivative (const F &f, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, int n, T &fx, T &dfx_dxn)
template<typename T_y1 , typename T_y2 >
void	check_matching_sizes (const char *function, const char *name1, const T_y1 &y1, const char *name2, const T_y2 &y2)
template<typename T_y >
void	check_nonzero_size (const char *function, const char *name, const T_y &y)
template<typename T_y >
void	check_ordered (const char *function, const char *name, const std::vector< T_y > &y)
double	dot (const std::vector< double > &x, const std::vector< double > &y)
double	dot_self (const std::vector< double > &x)
template<typename T , typename S >
void	fill (std::vector< T > &x, const S &y)
template<typename Vector >
void	inverse_softmax (const Vector &simplex, Vector &y)
double	log_sum_exp (const std::vector< double > &x)
template<typename T >
std::vector< T >	rep_array (const T &x, int n)
template<typename T >
std::vector< std::vector< T > >	rep_array (const T &x, int m, int n)
template<typename T >
std::vector< std::vector< std::vector< T > > >	rep_array (const T &x, int k, int m, int n)
void	scaled_add (std::vector< double > &x, const std::vector< double > &y, double lambda)
template<typename T >
std::vector< T >	sort_asc (std::vector< T > xs)
template<typename T >
std::vector< T >	sort_desc (std::vector< T > xs)
void	sub (std::vector< double > &x, std::vector< double > &y, std::vector< double > &result)
template<typename T >
T	sum (const std::vector< T > &xs)
template<typename T >
std::vector< typename child_type< T >::type >	value_of (const std::vector< T > &x)
template<>
std::vector< double >	value_of (const std::vector< double > &x)
template<typename T >
std::vector< double >	value_of_rec (const std::vector< T > &x)
template<>
std::vector< double >	value_of_rec (const std::vector< double > &x)
template<typename F >
double	integrate (const F &f, double a, double b, double tolerance)
template<typename F >
double	integrate_1d (const F &f, const double a, const double b, const std::vector< double > &theta, const std::vector< double > &x_r, const std::vector< int > &x_i, std::ostream &msgs, const double tolerance=std::sqrt(std::numeric_limits< double >::epsilon()))
template<typename F , typename T1 , typename T2 >
std::vector< std::vector< typename stan::return_type< T1, T2 >::type > >	integrate_ode_rk45 (const F &f, const std::vector< T1 > &y0, double t0, const std::vector< double > &ts, const std::vector< T2 > &theta, const std::vector< double > &x, const std::vector< int > &x_int, std::ostream *msgs=nullptr, double relative_tolerance=1e-6, double absolute_tolerance=1e-6, int max_num_steps=1E6)
template<typename T_y >
void	check_cholesky_factor (const char *function, const char *name, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y)
template<typename T_y >
void	check_cholesky_factor_corr (const char *function, const char *name, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y)
template<typename T_y , int R, int C>
void	check_column_index (const char *function, const char *name, const Eigen::Matrix< T_y, R, C > &y, size_t i)
template<typename T_y >
void	check_corr_matrix (const char *function, const char *name, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y)
template<typename T_y >
void	check_cov_matrix (const char *function, const char *name, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y)
template<typename T , int R, int C>
void	check_ldlt_factor (const char *function, const char *name, LDLT_factor< T, R, C > &A)
template<typename T_y >
void	check_lower_triangular (const char *function, const char *name, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y)
template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
void	check_matching_dims (const char *function, const char *name1, const Eigen::Matrix< T1, R1, C1 > &y1, const char *name2, const Eigen::Matrix< T2, R2, C2 > &y2)
template<bool check_compile, typename T1 , typename T2 , int R1, int C1, int R2, int C2>
void	check_matching_dims (const char *function, const char *name1, const Eigen::Matrix< T1, R1, C1 > &y1, const char *name2, const Eigen::Matrix< T2, R2, C2 > &y2)
template<typename T1 , typename T2 >
void	check_multiplicable (const char *function, const char *name1, const T1 &y1, const char *name2, const T2 &y2)
template<typename T_y >
void	check_ordered (const char *function, const char *name, const Eigen::Matrix< T_y, Eigen::Dynamic, 1 > &y)
template<typename T_y >
void	check_pos_definite (const char *function, const char *name, const Eigen::Matrix< T_y,-1,-1 > &y)
template<typename Derived >
void	check_pos_definite (const char *function, const char *name, const Eigen::LDLT< Derived > &cholesky)
template<typename Derived >
void	check_pos_definite (const char *function, const char *name, const Eigen::LLT< Derived > &cholesky)
template<typename T_y >
void	check_pos_semidefinite (const char *function, const char *name, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y)
template<typename T_y >
void	check_positive_ordered (const char *function, const char *name, const Eigen::Matrix< T_y, Eigen::Dynamic, 1 > &y)
void	check_range (const char *function, const char *name, int max, int index, int nested_level, const char *error_msg)
void	check_range (const char *function, const char *name, int max, int index, const char *error_msg)
void	check_range (const char *function, const char *name, int max, int index)
template<typename T_y , int R, int C>
void	check_row_index (const char *function, const char *name, const Eigen::Matrix< T_y, R, C > &y, size_t i)
template<typename T_prob >
void	check_simplex (const char *function, const char *name, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &theta)
template<typename T_y >
void	check_spsd_matrix (const char *function, const char *name, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y)
template<typename T_y >
void	check_square (const char *function, const char *name, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y)
template<typename T >
void	check_std_vector_index (const char *function, const char *name, const std::vector< T > &y, int i)
template<typename T_y >
void	check_symmetric (const char *function, const char *name, const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y)
template<typename T_prob >
void	check_unit_vector (const char *function, const char *name, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &theta)
template<typename T , int R, int C>
void	check_vector (const char *function, const char *name, const Eigen::Matrix< T, R, C > &x)
void	validate_non_negative_index (const char *var_name, const char *expr, int val)
template<typename T >
apply_scalar_unary< acos_fun, T >::return_t	acos (const T &x)
template<typename T >
apply_scalar_unary< acosh_fun, T >::return_t	acosh (const T &x)
template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R, C >	add (const Eigen::Matrix< T1, R, C > &m1, const Eigen::Matrix< T2, R, C > &m2)
template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R, C >	add (const Eigen::Matrix< T1, R, C > &m, const T2 &c)
template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R, C >	add (const T1 &c, const Eigen::Matrix< T2, R, C > &m)
template<typename T_m , typename T_a >
Eigen::Matrix< typename return_type< T_m, T_a >::type, Eigen::Dynamic, Eigen::Dynamic >	add_diag (const Eigen::Matrix< T_m,-1,-1 > &mat, const T_a &to_add)
template<typename T_m , int R, int C, typename T_a >
Eigen::Matrix< typename return_type< T_m, T_a >::type, Eigen::Dynamic, Eigen::Dynamic >	add_diag (const Eigen::Matrix< T_m,-1,-1 > &mat, const Eigen::Matrix< T_a, R, C > &to_add)
template<typename T1 , typename T2 >
append_return_type< std::vector< T1 >, std::vector< T2 > >::type	append_array (const std::vector< T1 > &x, const std::vector< T2 > &y)
template<typename T1 >
std::vector< T1 >	append_array (const std::vector< T1 > &x, const std::vector< T1 > &y)
template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename return_type< T1, T2 >::type, Eigen::Dynamic, Eigen::Dynamic >	append_col (const Eigen::Matrix< T1, R1, C1 > &A, const Eigen::Matrix< T2, R2, C2 > &B)
template<typename T1 , typename T2 , int C1, int C2>
Eigen::Matrix< typename return_type< T1, T2 >::type, 1, Eigen::Dynamic >	append_col (const Eigen::Matrix< T1, 1, C1 > &A, const Eigen::Matrix< T2, 1, C2 > &B)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	append_col (const Eigen::Matrix< T, R1, C1 > &A, const Eigen::Matrix< T, R2, C2 > &B)
template<typename T , int C1, int C2>
Eigen::Matrix< T, 1, Eigen::Dynamic >	append_col (const Eigen::Matrix< T, 1, C1 > &A, const Eigen::Matrix< T, 1, C2 > &B)
template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename return_type< T1, T2 >::type, 1, Eigen::Dynamic >	append_col (const T1 &A, const Eigen::Matrix< T2, R, C > &B)
template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename return_type< T1, T2 >::type, 1, Eigen::Dynamic >	append_col (const Eigen::Matrix< T1, R, C > &A, const T2 &B)
template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename return_type< T1, T2 >::type, Eigen::Dynamic, Eigen::Dynamic >	append_row (const Eigen::Matrix< T1, R1, C1 > &A, const Eigen::Matrix< T2, R2, C2 > &B)
template<typename T1 , typename T2 , int R1, int R2>
Eigen::Matrix< typename return_type< T1, T2 >::type, Eigen::Dynamic, 1 >	append_row (const Eigen::Matrix< T1, R1, 1 > &A, const Eigen::Matrix< T2, R2, 1 > &B)
template<typename T , int R1, int C1, int R2, int C2>
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	append_row (const Eigen::Matrix< T, R1, C1 > &A, const Eigen::Matrix< T, R2, C2 > &B)
template<typename T , int R1, int R2>
Eigen::Matrix< T, Eigen::Dynamic, 1 >	append_row (const Eigen::Matrix< T, R1, 1 > &A, const Eigen::Matrix< T, R2, 1 > &B)
template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename return_type< T1, T2 >::type, Eigen::Dynamic, 1 >	append_row (const T1 &A, const Eigen::Matrix< T2, R, C > &B)
template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename return_type< T1, T2 >::type, Eigen::Dynamic, 1 >	append_row (const Eigen::Matrix< T1, R, C > &A, const T2 &B)
template<typename T >
apply_scalar_unary< asin_fun, T >::return_t	asin (const T &x)
template<typename T >
apply_scalar_unary< asinh_fun, T >::return_t	asinh (const T &x)
template<int N>
void	print_mat_size (std::ostream &o)
template<typename T_lhs , typename T_rhs >
void	assign (T_lhs &x, const T_rhs &y)
template<typename T_lhs , typename T_rhs , int R1, int C1, int R2, int C2>
void	assign (Eigen::Matrix< T_lhs, R1, C1 > &x, const Eigen::Matrix< T_rhs, R2, C2 > &y)
template<typename T_lhs , typename T_rhs , int R, int C>
void	assign (Eigen::Matrix< T_lhs, R, C > &x, const Eigen::Matrix< T_rhs, R, C > &y)
template<typename T_lhs , typename T , int R, int C>
void	assign (Eigen::Block< T_lhs > x, const Eigen::Matrix< T, R, C > &y)
template<typename T_lhs , typename T_rhs >
void	assign (std::vector< T_lhs > &x, const std::vector< T_rhs > &y)
template<typename T >
apply_scalar_unary< atan_fun, T >::return_t	atan (const T &x)
template<typename T >
apply_scalar_unary< atanh_fun, T >::return_t	atanh (const T &x)
template<typename T >
void	autocorrelation (const std::vector< T > &y, std::vector< T > &ac, Eigen::FFT< T > &fft)
template<typename T , typename DerivedA , typename DerivedB >
void	autocorrelation (const Eigen::MatrixBase< DerivedA > &y, Eigen::MatrixBase< DerivedB > &ac, Eigen::FFT< T > &fft)
template<typename T >
void	autocorrelation (const std::vector< T > &y, std::vector< T > &ac)
template<typename T , typename DerivedA , typename DerivedB >
void	autocorrelation (const Eigen::MatrixBase< DerivedA > &y, Eigen::MatrixBase< DerivedB > &ac)
template<typename T >
void	autocovariance (const std::vector< T > &y, std::vector< T > &acov, Eigen::FFT< T > &fft)
template<typename T , typename DerivedA , typename DerivedB >
void	autocovariance (const Eigen::MatrixBase< DerivedA > &y, Eigen::MatrixBase< DerivedB > &acov, Eigen::FFT< T > &fft)
template<typename T >
void	autocovariance (const std::vector< T > &y, std::vector< T > &acov)
template<typename T , typename DerivedA , typename DerivedB >
void	autocovariance (const Eigen::MatrixBase< DerivedA > &y, Eigen::MatrixBase< DerivedB > &acov)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	block (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m, size_t i, size_t j, size_t nrows, size_t ncols)
template<typename T >
apply_scalar_unary< cbrt_fun, T >::return_t	cbrt (const T &x)
template<typename T >
apply_scalar_unary< ceil_fun, T >::return_t	ceil (const T &x)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	chol2inv (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &L)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	cholesky_corr_constrain (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &y, int K)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	cholesky_corr_constrain (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &y, int K, T &lp)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	cholesky_corr_free (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &x)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	cholesky_decompose (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	cholesky_factor_constrain (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, int M, int N)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	cholesky_factor_constrain (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, int M, int N, T &lp)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	cholesky_factor_free (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &y)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	col (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m, size_t j)
template<typename T , int R, int C>
int	cols (const Eigen::Matrix< T, R, C > &m)
template<int R1, int C1, int R2, int C2>
Eigen::Matrix< double, 1, C1 >	columns_dot_product (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< double, R2, C2 > &v2)
template<typename T , int R, int C>
Eigen::Matrix< T, 1, C >	columns_dot_self (const Eigen::Matrix< T, R, C > &x)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	corr_matrix_constrain (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, typename math::index_type< Eigen::Matrix< T, Eigen::Dynamic, 1 > >::type k)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	corr_matrix_constrain (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, typename math::index_type< Eigen::Matrix< T, Eigen::Dynamic, 1 > >::type k, T &lp)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	corr_matrix_free (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &y)
template<typename T >
apply_scalar_unary< cos_fun, T >::return_t	cos (const T &x)
template<typename T >
apply_scalar_unary< cosh_fun, T >::return_t	cosh (const T &x)
template<typename T_x , typename T_sigma , typename T_l >
Eigen::Matrix< typename stan::return_type< T_x, T_sigma, T_l >::type, Eigen::Dynamic, Eigen::Dynamic >	cov_exp_quad (const std::vector< T_x > &x, const T_sigma &sigma, const T_l &length_scale)
template<typename T_x , typename T_sigma , typename T_l >
Eigen::Matrix< typename stan::return_type< T_x, T_sigma, T_l >::type, Eigen::Dynamic, Eigen::Dynamic >	cov_exp_quad (const std::vector< T_x > &x, const T_sigma &sigma, const std::vector< T_l > &length_scale)
template<typename T_x1 , typename T_x2 , typename T_sigma , typename T_l >
Eigen::Matrix< typename stan::return_type< T_x1, T_x2, T_sigma, T_l >::type, Eigen::Dynamic, Eigen::Dynamic >	cov_exp_quad (const std::vector< T_x1 > &x1, const std::vector< T_x2 > &x2, const T_sigma &sigma, const T_l &length_scale)
template<typename T_x1 , typename T_x2 , typename T_sigma , typename T_l >
Eigen::Matrix< typename stan::return_type< T_x1, T_x2, T_sigma, T_l >::type, Eigen::Dynamic, Eigen::Dynamic >	cov_exp_quad (const std::vector< T_x1 > &x1, const std::vector< T_x2 > &x2, const T_sigma &sigma, const std::vector< T_l > &length_scale)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	cov_matrix_constrain (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, typename math::index_type< Eigen::Matrix< T, Eigen::Dynamic, 1 > >::type K)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	cov_matrix_constrain (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, typename math::index_type< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > >::type K, T &lp)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	cov_matrix_constrain_lkj (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, size_t k)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	cov_matrix_constrain_lkj (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, size_t k, T &lp)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	cov_matrix_free (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &y)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	cov_matrix_free_lkj (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &y)
matrix_d	crossprod (const matrix_d &M)
template<typename T >
const std::vector< int >	csr_extract_u (const Eigen::SparseMatrix< T, Eigen::RowMajor > &A)
template<typename T , int R, int C>
const std::vector< int >	csr_extract_u (const Eigen::Matrix< T, R, C > &A)
template<typename T >
const std::vector< int >	csr_extract_v (const Eigen::SparseMatrix< T, Eigen::RowMajor > &A)
template<typename T , int R, int C>
const std::vector< int >	csr_extract_v (const Eigen::Matrix< T, R, C > &A)
template<typename T >
const Eigen::Matrix< T, Eigen::Dynamic, 1 >	csr_extract_w (const Eigen::SparseMatrix< T, Eigen::RowMajor > &A)
template<typename T , int R, int C>
const Eigen::Matrix< T, Eigen::Dynamic, 1 >	csr_extract_w (const Eigen::Matrix< T, R, C > &A)
template<typename T1 , typename T2 >
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, Eigen::Dynamic, 1 >	csr_matrix_times_vector (int m, int n, const Eigen::Matrix< T1, Eigen::Dynamic, 1 > &w, const std::vector< int > &v, const std::vector< int > &u, const Eigen::Matrix< T2, Eigen::Dynamic, 1 > &b)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	csr_to_dense_matrix (int m, int n, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &w, const std::vector< int > &v, const std::vector< int > &u)
int	csr_u_to_z (const std::vector< int > &u, int i)
template<typename T >
std::vector< T >	cumulative_sum (const std::vector< T > &x)
template<typename T , int R, int C>
Eigen::Matrix< T, R, C >	cumulative_sum (const Eigen::Matrix< T, R, C > &m)
template<typename T , int R, int C>
T	determinant (const Eigen::Matrix< T, R, C > &m)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	diag_matrix (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &v)
template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R1, C1 >	diag_post_multiply (const Eigen::Matrix< T1, R1, C1 > &m1, const Eigen::Matrix< T2, R2, C2 > &m2)
template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R2, C2 >	diag_pre_multiply (const Eigen::Matrix< T1, R1, C1 > &m1, const Eigen::Matrix< T2, R2, C2 > &m2)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	diagonal (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
template<typename T >
apply_scalar_unary< digamma_fun, T >::return_t	digamma (const T &x)
template<typename T >
void	dims (const T &x, std::vector< int > &result)
template<typename T , int R, int C>
void	dims (const Eigen::Matrix< T, R, C > &x, std::vector< int > &result)
template<typename T >
void	dims (const std::vector< T > &x, std::vector< int > &result)
template<typename T >
std::vector< int >	dims (const T &x)
template<typename T1 , int R1, int C1, typename T2 , int R2, int C2>
boost::math::tools::promote_args< T1, T2 >::type	distance (const Eigen::Matrix< T1, R1, C1 > &v1, const Eigen::Matrix< T2, R2, C2 > &v2)
template<int R, int C, typename T >
boost::enable_if_c< boost::is_arithmetic< T >::value, Eigen::Matrix< double, R, C > >::type	divide (const Eigen::Matrix< double, R, C > &m, T c)
template<int R1, int C1, int R2, int C2>
double	dot_product (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< double, R2, C2 > &v2)
double	dot_product (const double *v1, const double *v2, size_t length)
double	dot_product (const std::vector< double > &v1, const std::vector< double > &v2)
template<int R, int C>
double	dot_self (const Eigen::Matrix< double, R, C > &v)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	eigenvalues_sym (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	eigenvectors_sym (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R, C >	elt_divide (const Eigen::Matrix< T1, R, C > &m1, const Eigen::Matrix< T2, R, C > &m2)
template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R, C >	elt_divide (const Eigen::Matrix< T1, R, C > &m, T2 s)
template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R, C >	elt_divide (T1 s, const Eigen::Matrix< T2, R, C > &m)
template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R, C >	elt_multiply (const Eigen::Matrix< T1, R, C > &m1, const Eigen::Matrix< T2, R, C > &m2)
template<typename T >
apply_scalar_unary< erf_fun, T >::return_t	erf (const T &x)
template<typename T >
apply_scalar_unary< erfc_fun, T >::return_t	erfc (const T &x)
template<typename T >
apply_scalar_unary< exp_fun, T >::return_t	exp (const T &x)
template<typename T >
apply_scalar_unary< exp2_fun, T >::return_t	exp2 (const T &x)
template<typename T >
apply_scalar_unary< expm1_fun, T >::return_t	expm1 (const T &x)
template<typename T >
apply_scalar_unary< fabs_fun, T >::return_t	fabs (const T &x)
template<typename T >
bool	factor_cov_matrix (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &Sigma, Eigen::Array< T, Eigen::Dynamic, 1 > &CPCs, Eigen::Array< T, Eigen::Dynamic, 1 > &sds)
template<typename T >
void	factor_U (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &U, Eigen::Array< T, Eigen::Dynamic, 1 > &CPCs)
template<typename T , int R, int C, typename S >
void	fill (Eigen::Matrix< T, R, C > &x, const S &y)
template<typename T >
apply_scalar_unary< floor_fun, T >::return_t	floor (const T &x)
template<typename T >
const T &	get_base1 (const std::vector< T > &x, size_t i, const char *error_msg, size_t idx)
template<typename T >
const T &	get_base1 (const std::vector< std::vector< T > > &x, size_t i1, size_t i2, const char *error_msg, size_t idx)
template<typename T >
const T &	get_base1 (const std::vector< std::vector< std::vector< T > > > &x, size_t i1, size_t i2, size_t i3, const char *error_msg, size_t idx)
template<typename T >
const T &	get_base1 (const std::vector< std::vector< std::vector< std::vector< T > > > > &x, size_t i1, size_t i2, size_t i3, size_t i4, const char *error_msg, size_t idx)
template<typename T >
const T &	get_base1 (const std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > &x, size_t i1, size_t i2, size_t i3, size_t i4, size_t i5, const char *error_msg, size_t idx)
template<typename T >
const T &	get_base1 (const std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > > &x, size_t i1, size_t i2, size_t i3, size_t i4, size_t i5, size_t i6, const char *error_msg, size_t idx)
template<typename T >
const T &	get_base1 (const std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > > > &x, size_t i1, size_t i2, size_t i3, size_t i4, size_t i5, size_t i6, size_t i7, const char *error_msg, size_t idx)
template<typename T >
const T &	get_base1 (const std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > > > > &x, size_t i1, size_t i2, size_t i3, size_t i4, size_t i5, size_t i6, size_t i7, size_t i8, const char *error_msg, size_t idx)
template<typename T >
Eigen::Matrix< T, 1, Eigen::Dynamic >	get_base1 (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &x, size_t m, const char *error_msg, size_t idx)
template<typename T >
const T &	get_base1 (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &x, size_t m, size_t n, const char *error_msg, size_t idx)
template<typename T >
const T &	get_base1 (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, size_t m, const char *error_msg, size_t idx)
template<typename T >
const T &	get_base1 (const Eigen::Matrix< T, 1, Eigen::Dynamic > &x, size_t n, const char *error_msg, size_t idx)
template<typename T >
T &	get_base1_lhs (std::vector< T > &x, size_t i, const char *error_msg, size_t idx)
template<typename T >
T &	get_base1_lhs (std::vector< std::vector< T > > &x, size_t i1, size_t i2, const char *error_msg, size_t idx)
template<typename T >
T &	get_base1_lhs (std::vector< std::vector< std::vector< T > > > &x, size_t i1, size_t i2, size_t i3, const char *error_msg, size_t idx)
template<typename T >
T &	get_base1_lhs (std::vector< std::vector< std::vector< std::vector< T > > > > &x, size_t i1, size_t i2, size_t i3, size_t i4, const char *error_msg, size_t idx)
template<typename T >
T &	get_base1_lhs (std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > &x, size_t i1, size_t i2, size_t i3, size_t i4, size_t i5, const char *error_msg, size_t idx)
template<typename T >
T &	get_base1_lhs (std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > > &x, size_t i1, size_t i2, size_t i3, size_t i4, size_t i5, size_t i6, const char *error_msg, size_t idx)
template<typename T >
T &	get_base1_lhs (std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > > > &x, size_t i1, size_t i2, size_t i3, size_t i4, size_t i5, size_t i6, size_t i7, const char *error_msg, size_t idx)
template<typename T >
T &	get_base1_lhs (std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< std::vector< T > > > > > > > > &x, size_t i1, size_t i2, size_t i3, size_t i4, size_t i5, size_t i6, size_t i7, size_t i8, const char *error_msg, size_t idx)
template<typename T >
Eigen::Block< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > >	get_base1_lhs (Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &x, size_t m, const char *error_msg, size_t idx)
template<typename T >
T &	get_base1_lhs (Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &x, size_t m, size_t n, const char *error_msg, size_t idx)
template<typename T >
T &	get_base1_lhs (Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, size_t m, const char *error_msg, size_t idx)
template<typename T >
T &	get_base1_lhs (Eigen::Matrix< T, 1, Eigen::Dynamic > &x, size_t n, const char *error_msg, size_t idx)
template<typename T_lp , typename T_lp_accum >
boost::math::tools::promote_args< T_lp, T_lp_accum >::type	get_lp (const T_lp &lp, const accumulator< T_lp_accum > &lp_accum)
template<typename T_x , typename T_sigma >
Eigen::Matrix< typename stan::return_type< T_x, T_sigma >::type, Eigen::Dynamic, Eigen::Dynamic >	gp_dot_prod_cov (const std::vector< T_x > &x, const T_sigma &sigma)
template<typename T_sigma >
Eigen::Matrix< typename stan::return_type< double, T_sigma >::type, Eigen::Dynamic, Eigen::Dynamic >	gp_dot_prod_cov (const std::vector< double > &x, const T_sigma &sigma)
template<typename T_x1 , typename T_x2 , typename T_sigma >
Eigen::Matrix< typename stan::return_type< T_x1, T_x2, T_sigma >::type, Eigen::Dynamic, Eigen::Dynamic >	gp_dot_prod_cov (const std::vector< T_x1 > &x1, const std::vector< T_x2 > &x2, const T_sigma &sigma)
template<typename T_sigma >
Eigen::Matrix< typename stan::return_type< double, T_sigma >::type, Eigen::Dynamic, Eigen::Dynamic >	gp_dot_prod_cov (const std::vector< double > &x1, const std::vector< double > &x2, const T_sigma &sigma)
template<typename T_x , typename T_sigma , typename T_l , typename T_p >
Eigen::Matrix< typename stan::return_type< T_x, T_sigma, T_l, T_p >::type, Eigen::Dynamic, Eigen::Dynamic >	gp_periodic_cov (const std::vector< T_x > &x, const T_sigma &sigma, const T_l &l, const T_p &p)
template<typename T_x1 , typename T_x2 , typename T_sigma , typename T_l , typename T_p >
Eigen::Matrix< typename stan::return_type< T_x1, T_x2, T_sigma, T_l, T_p >::type, Eigen::Dynamic, Eigen::Dynamic >	gp_periodic_cov (const std::vector< T_x1 > &x1, const std::vector< T_x2 > &x2, const T_sigma &sigma, const T_l &l, const T_p &p)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	head (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &v, size_t n)
template<typename T >
Eigen::Matrix< T, 1, Eigen::Dynamic >	head (const Eigen::Matrix< T, 1, Eigen::Dynamic > &rv, size_t n)
template<typename T >
std::vector< T >	head (const std::vector< T > &sv, size_t n)
template<typename T >
void	initialize (T &x, const T &v)
template<typename T , typename V >
boost::enable_if_c< boost::is_arithmetic< V >::value, void >::type	initialize (T &x, V v)
template<typename T , int R, int C, typename V >
void	initialize (Eigen::Matrix< T, R, C > &x, const V &v)
template<typename T , typename V >
void	initialize (std::vector< T > &x, const V &v)
template<typename T >
apply_scalar_unary< inv_fun, T >::return_t	inv (const T &x)
template<typename T >
apply_scalar_unary< inv_cloglog_fun, T >::return_t	inv_cloglog (const T &x)
template<typename T >
apply_scalar_unary< inv_logit_fun, T >::return_t	inv_logit (const T &x)
template<typename T >
apply_scalar_unary< inv_Phi_fun, T >::return_t	inv_Phi (const T &x)
template<typename T >
apply_scalar_unary< inv_sqrt_fun, T >::return_t	inv_sqrt (const T &x)
template<typename T >
apply_scalar_unary< inv_square_fun, T >::return_t	inv_square (const T &x)
template<typename T , int R, int C>
Eigen::Matrix< T, R, C >	inverse (const Eigen::Matrix< T, R, C > &m)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	inverse_spd (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
template<typename T >
apply_scalar_unary< lgamma_fun, T >::return_t	lgamma (const T &x)
template<typename T >
apply_scalar_unary< log_fun, T >::return_t	log (const T &x)
template<typename T >
apply_scalar_unary< log10_fun, T >::return_t	log10 (const T &x)
template<typename T >
apply_scalar_unary< log1m_fun, T >::return_t	log1m (const T &x)
template<typename T >
apply_scalar_unary< log1m_exp_fun, T >::return_t	log1m_exp (const T &x)
template<typename T >
apply_scalar_unary< log1m_inv_logit_fun, T >::return_t	log1m_inv_logit (const T &x)
template<typename T >
apply_scalar_unary< log1p_fun, T >::return_t	log1p (const T &x)
template<typename T >
apply_scalar_unary< log1p_exp_fun, T >::return_t	log1p_exp (const T &x)
template<typename T >
apply_scalar_unary< log2_fun, T >::return_t	log2 (const T &x)
template<typename T , int R, int C>
T	log_determinant (const Eigen::Matrix< T, R, C > &m)
template<int R, int C, typename T >
T	log_determinant_ldlt (LDLT_factor< T, R, C > &A)
template<typename T , int R, int C>
T	log_determinant_spd (const Eigen::Matrix< T, R, C > &m)
template<typename T >
apply_scalar_unary< log_inv_logit_fun, T >::return_t	log_inv_logit (const T &x)
template<typename T_theta , typename T_lam >
return_type< T_theta, T_lam >::type	log_mix (const T_theta &theta, const T_lam &lambda)
template<typename T_theta , typename T_lam , int R, int C>
return_type< T_theta, std::vector< Eigen::Matrix< T_lam, R, C > > >::type	log_mix (const T_theta &theta, const std::vector< Eigen::Matrix< T_lam, R, C > > &lambda)
template<typename T_theta , typename T_lam >
return_type< T_theta, std::vector< std::vector< T_lam > > >::type	log_mix (const T_theta &theta, const std::vector< std::vector< T_lam > > &lambda)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	log_softmax (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &v)
template<int R, int C>
double	log_sum_exp (const Eigen::Matrix< double, R, C > &x)
template<typename T >
apply_scalar_unary< logit_fun, T >::return_t	logit (const T &x)
template<typename T >
Eigen::Array< T, Eigen::Dynamic, 1 >	make_nu (const T &eta, size_t K)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	matrix_exp (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &A)
template<typename T , int N>
Eigen::Matrix< T, N, N >	matrix_exp (const Eigen::Matrix< T, N, N > &A)
template<typename T >
Eigen::Matrix< T, 1, 1 >	matrix_exp (const Eigen::Matrix< T, 1, 1 > &A)
template<typename Mtype >
Mtype	matrix_exp_2x2 (const Mtype &A)
template<int Cb>
Eigen::Matrix< double,-1, Cb >	matrix_exp_multiply (const Eigen::MatrixXd &A, const Eigen::Matrix< double,-1, Cb > &B)
template<typename MatrixType >
MatrixType	matrix_exp_pade (const MatrixType &arg)
int	max (const std::vector< int > &x)
template<typename T >
T	max (const std::vector< T > &x)
template<typename T , int R, int C>
T	max (const Eigen::Matrix< T, R, C > &m)
template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R1, C2 >	mdivide_left (const Eigen::Matrix< T1, R1, C1 > &A, const Eigen::Matrix< T2, R2, C2 > &b)
template<int R1, int C1, int R2, int C2, typename T1 , typename T2 >
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R1, C2 >	mdivide_left_ldlt (const LDLT_factor< T1, R1, C1 > &A, const Eigen::Matrix< T2, R2, C2 > &b)
template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R1, C2 >	mdivide_left_spd (const Eigen::Matrix< T1, R1, C1 > &A, const Eigen::Matrix< T2, R2, C2 > &b)
template<int TriView, typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R1, C2 >	mdivide_left_tri (const Eigen::Matrix< T1, R1, C1 > &A, const Eigen::Matrix< T2, R2, C2 > &b)
template<int TriView, typename T , int R1, int C1>
Eigen::Matrix< T, R1, C1 >	mdivide_left_tri (const Eigen::Matrix< T, R1, C1 > &A)
template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R1, C2 >	mdivide_left_tri_low (const Eigen::Matrix< T1, R1, C1 > &A, const Eigen::Matrix< T2, R2, C2 > &b)
template<typename T , int R1, int C1>
Eigen::Matrix< T, R1, C1 >	mdivide_left_tri_low (const Eigen::Matrix< T, R1, C1 > &A)
template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R1, C2 >	mdivide_right (const Eigen::Matrix< T1, R1, C1 > &b, const Eigen::Matrix< T2, R2, C2 > &A)
template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R1, C2 >	mdivide_right_ldlt (const Eigen::Matrix< T1, R1, C1 > &b, const LDLT_factor< T2, R2, C2 > &A)
template<int R1, int C1, int R2, int C2>
Eigen::Matrix< double, R1, C2 >	mdivide_right_ldlt (const Eigen::Matrix< double, R1, C1 > &b, const LDLT_factor< double, R2, C2 > &A)
template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R1, C2 >	mdivide_right_spd (const Eigen::Matrix< T1, R1, C1 > &b, const Eigen::Matrix< T2, R2, C2 > &A)
template<int TriView, typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R1, C2 >	mdivide_right_tri (const Eigen::Matrix< T1, R1, C1 > &b, const Eigen::Matrix< T2, R2, C2 > &A)
template<typename T1 , typename T2 , int R1, int C1, int R2, int C2>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R1, C2 >	mdivide_right_tri_low (const Eigen::Matrix< T1, R1, C1 > &b, const Eigen::Matrix< T2, R2, C2 > &A)
template<typename T >
boost::math::tools::promote_args< T >::type	mean (const std::vector< T > &v)
template<typename T , int R, int C>
boost::math::tools::promote_args< T >::type	mean (const Eigen::Matrix< T, R, C > &m)
int	min (const std::vector< int > &x)
template<typename T >
T	min (const std::vector< T > &x)
template<typename T , int R, int C>
T	min (const Eigen::Matrix< T, R, C > &m)
template<typename T >
T	minus (const T &x)
template<int R, int C, typename T >
boost::enable_if_c< boost::is_arithmetic< T >::value, Eigen::Matrix< double, R, C > >::type	multiply (const Eigen::Matrix< double, R, C > &m, T c)
template<int R, int C, typename T >
boost::enable_if_c< boost::is_arithmetic< T >::value, Eigen::Matrix< double, R, C > >::type	multiply (T c, const Eigen::Matrix< double, R, C > &m)
template<int R1, int C1, int R2, int C2>
Eigen::Matrix< double, R1, C2 >	multiply (const Eigen::Matrix< double, R1, C1 > &m1, const Eigen::Matrix< double, R2, C2 > &m2)
template<int C1, int R2>
double	multiply (const Eigen::Matrix< double, 1, C1 > &rv, const Eigen::Matrix< double, R2, 1 > &v)
matrix_d	multiply_lower_tri_self_transpose (const matrix_d &L)
template<typename T >
int	num_elements (const T &x)
template<typename T , int R, int C>
int	num_elements (const Eigen::Matrix< T, R, C > &m)
template<typename T >
int	num_elements (const std::vector< T > &v)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	ordered_constrain (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	ordered_constrain (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, T &lp)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	ordered_free (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &y)
template<typename T >
apply_scalar_unary< Phi_fun, T >::return_t	Phi (const T &x)
template<typename T >
apply_scalar_unary< Phi_approx_fun, T >::return_t	Phi_approx (const T &x)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	positive_ordered_constrain (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	positive_ordered_constrain (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, T &lp)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	positive_ordered_free (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &y)
template<typename T >
T	prod (const std::vector< T > &v)
template<typename T , int R, int C>
T	prod (const Eigen::Matrix< T, R, C > &v)
template<typename T1 , typename T2 , typename F >
common_type< T1, T2 >::type	promote_common (const F &u)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	qr_Q (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	qr_R (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	qr_thin_Q (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	qr_thin_R (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
template<int RA, int CA, int RB, int CB, typename T >
Eigen::Matrix< T, CB, CB >	quad_form (const Eigen::Matrix< T, RA, CA > &A, const Eigen::Matrix< T, RB, CB > &B)
template<int RA, int CA, int RB, typename T >
T	quad_form (const Eigen::Matrix< T, RA, CA > &A, const Eigen::Matrix< T, RB, 1 > &B)
template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, Eigen::Dynamic, Eigen::Dynamic >	quad_form_diag (const Eigen::Matrix< T1, Eigen::Dynamic, Eigen::Dynamic > &mat, const Eigen::Matrix< T2, R, C > &vec)
template<int RA, int CA, int RB, int CB, typename T >
Eigen::Matrix< T, CB, CB >	quad_form_sym (const Eigen::Matrix< T, RA, CA > &A, const Eigen::Matrix< T, RB, CB > &B)
template<int RA, int CA, int RB, typename T >
T	quad_form_sym (const Eigen::Matrix< T, RA, CA > &A, const Eigen::Matrix< T, RB, 1 > &B)
template<typename C >
int	rank (const C &v, int s)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	read_corr_L (const Eigen::Array< T, Eigen::Dynamic, 1 > &CPCs, size_t K)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	read_corr_L (const Eigen::Array< T, Eigen::Dynamic, 1 > &CPCs, size_t K, T &log_prob)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	read_corr_matrix (const Eigen::Array< T, Eigen::Dynamic, 1 > &CPCs, size_t K)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	read_corr_matrix (const Eigen::Array< T, Eigen::Dynamic, 1 > &CPCs, size_t K, T &log_prob)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	read_cov_L (const Eigen::Array< T, Eigen::Dynamic, 1 > &CPCs, const Eigen::Array< T, Eigen::Dynamic, 1 > &sds, T &log_prob)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	read_cov_matrix (const Eigen::Array< T, Eigen::Dynamic, 1 > &CPCs, const Eigen::Array< T, Eigen::Dynamic, 1 > &sds, T &log_prob)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	read_cov_matrix (const Eigen::Array< T, Eigen::Dynamic, 1 > &CPCs, const Eigen::Array< T, Eigen::Dynamic, 1 > &sds)
template<typename T >
Eigen::Matrix< typename boost::math::tools::promote_args< T >::type, Eigen::Dynamic, Eigen::Dynamic >	rep_matrix (const T &x, int m, int n)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	rep_matrix (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &v, int n)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	rep_matrix (const Eigen::Matrix< T, 1, Eigen::Dynamic > &rv, int m)
template<typename T >
Eigen::Matrix< typename boost::math::tools::promote_args< T >::type, 1, Eigen::Dynamic >	rep_row_vector (const T &x, int m)
template<typename T >
Eigen::Matrix< typename boost::math::tools::promote_args< T >::type, Eigen::Dynamic, 1 >	rep_vector (const T &x, int n)
template<typename T >
void	resize (T &x, std::vector< int > dims)
template<typename T >
apply_scalar_unary< round_fun, T >::return_t	round (const T &x)
template<typename T >
Eigen::Matrix< T, 1, Eigen::Dynamic >	row (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m, size_t i)
template<typename T , int R, int C>
int	rows (const Eigen::Matrix< T, R, C > &m)
template<int R1, int C1, int R2, int C2>
Eigen::Matrix< double, R1, 1 >	rows_dot_product (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< double, R2, C2 > &v2)
template<typename T , int R, int C>
Eigen::Matrix< T, R, 1 >	rows_dot_self (const Eigen::Matrix< T, R, C > &x)
template<int Cb>
Eigen::Matrix< double,-1, Cb >	scale_matrix_exp_multiply (const double &t, const Eigen::MatrixXd &A, const Eigen::Matrix< double,-1, Cb > &B)
template<typename T >
boost::math::tools::promote_args< T >::type	sd (const std::vector< T > &v)
template<typename T , int R, int C>
boost::math::tools::promote_args< T >::type	sd (const Eigen::Matrix< T, R, C > &m)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	segment (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &v, size_t i, size_t n)
template<typename T >
Eigen::Matrix< T, 1, Eigen::Dynamic >	segment (const Eigen::Matrix< T, 1, Eigen::Dynamic > &v, size_t i, size_t n)
template<typename T >
std::vector< T >	segment (const std::vector< T > &sv, size_t i, size_t n)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	simplex_constrain (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &y)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	simplex_constrain (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &y, T &lp)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	simplex_free (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x)
template<typename T >
apply_scalar_unary< sin_fun, T >::return_t	sin (const T &x)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	singular_values (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
template<typename T >
apply_scalar_unary< sinh_fun, T >::return_t	sinh (const T &x)
template<typename T >
int	size (const std::vector< T > &x)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	softmax (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &v)
template<typename T , int R, int C>
Eigen::Matrix< T, R, C >	sort_asc (Eigen::Matrix< T, R, C > xs)
template<typename T , int R, int C>
Eigen::Matrix< T, R, C >	sort_desc (Eigen::Matrix< T, R, C > xs)
template<typename C >
std::vector< int >	sort_indices_asc (const C &xs)
template<typename C >
std::vector< int >	sort_indices_desc (const C &xs)
template<typename T >
apply_scalar_unary< sqrt_fun, T >::return_t	sqrt (const T &x)
template<typename T >
apply_scalar_unary< square_fun, T >::return_t	square (const T &x)
template<int R, int C>
double	squared_distance (const Eigen::Matrix< double, R, C > &v1, const Eigen::Matrix< double, R, C > &v2)
template<int R1, int C1, int R2, int C2>
double	squared_distance (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< double, R2, C2 > &v2)
template<typename T >
void	stan_print (std::ostream *o, const T &x)
template<typename T >
void	stan_print (std::ostream *o, const std::vector< T > &x)
template<typename T >
void	stan_print (std::ostream *o, const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x)
template<typename T >
void	stan_print (std::ostream *o, const Eigen::Matrix< T, 1, Eigen::Dynamic > &x)
template<typename T >
void	stan_print (std::ostream *o, const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &x)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	sub_col (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m, size_t i, size_t j, size_t nrows)
template<typename T >
Eigen::Matrix< T, 1, Eigen::Dynamic >	sub_row (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m, size_t i, size_t j, size_t ncols)
template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R, C >	subtract (const Eigen::Matrix< T1, R, C > &m1, const Eigen::Matrix< T2, R, C > &m2)
template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R, C >	subtract (const T1 &c, const Eigen::Matrix< T2, R, C > &m)
template<typename T1 , typename T2 , int R, int C>
Eigen::Matrix< typename boost::math::tools::promote_args< T1, T2 >::type, R, C >	subtract (const Eigen::Matrix< T1, R, C > &m, const T2 &c)
template<typename T , int R, int C>
double	sum (const Eigen::Matrix< T, R, C > &v)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	tail (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &v, size_t n)
template<typename T >
Eigen::Matrix< T, 1, Eigen::Dynamic >	tail (const Eigen::Matrix< T, 1, Eigen::Dynamic > &rv, size_t n)
template<typename T >
std::vector< T >	tail (const std::vector< T > &sv, size_t n)
template<typename T >
apply_scalar_unary< tan_fun, T >::return_t	tan (const T &x)
template<typename T >
apply_scalar_unary< tanh_fun, T >::return_t	tanh (const T &x)
matrix_d	tcrossprod (const matrix_d &M)
template<typename T >
apply_scalar_unary< tgamma_fun, T >::return_t	tgamma (const T &x)
template<typename T , int R, int C>
std::vector< T >	to_array_1d (const Eigen::Matrix< T, R, C > &matrix)
template<typename T >
std::vector< T >	to_array_1d (const std::vector< T > &x)
template<typename T >
std::vector< typename scalar_type< T >::type >	to_array_1d (const std::vector< std::vector< T > > &x)
template<typename T >
std::vector< std::vector< T > >	to_array_2d (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &matrix)
template<typename T , int R, int C>
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	to_matrix (const Eigen::Matrix< T, R, C > &x)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	to_matrix (const std::vector< Eigen::Matrix< T, 1, Eigen::Dynamic > > &x)
template<typename T >
Eigen::Matrix< typename boost::math::tools::promote_args< T, double >::type, Eigen::Dynamic, Eigen::Dynamic >	to_matrix (const std::vector< std::vector< T > > &x)
template<typename T , int R, int C>
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	to_matrix (const Eigen::Matrix< T, R, C > &x, int m, int n)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	to_matrix (const std::vector< T > &x, int m, int n)
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic >	to_matrix (const std::vector< int > &x, int m, int n)
template<typename T , int R, int C>
Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic >	to_matrix (const Eigen::Matrix< T, R, C > &x, int m, int n, bool col_major)
template<typename T >
Eigen::Matrix< typename boost::math::tools::promote_args< T, double >::type, Eigen::Dynamic, Eigen::Dynamic >	to_matrix (const std::vector< T > &x, int m, int n, bool col_major)
template<typename T , int R, int C>
Eigen::Matrix< T, 1, Eigen::Dynamic >	to_row_vector (const Eigen::Matrix< T, R, C > &matrix)
template<typename T >
Eigen::Matrix< T, 1, Eigen::Dynamic >	to_row_vector (const std::vector< T > &vec)
Eigen::Matrix< double, 1, Eigen::Dynamic >	to_row_vector (const std::vector< int > &vec)
template<typename T , int R, int C>
Eigen::Matrix< T, Eigen::Dynamic, 1 >	to_vector (const Eigen::Matrix< T, R, C > &matrix)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	to_vector (const std::vector< T > &vec)
Eigen::Matrix< double, Eigen::Dynamic, 1 >	to_vector (const std::vector< int > &vec)
template<typename T >
T	trace (const Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic > &m)
template<typename T >
T	trace (const T &m)
template<typename T1 , typename T2 , typename T3 , int R1, int C1, int R2, int C2, int R3, int C3>
boost::enable_if_c< !stan::is_var< T1 >::value &&!stan::is_var< T2 >::value &&!stan::is_var< T3 >::value, typename boost::math::tools::promote_args< T1, T2, T3 >::type >::type	trace_gen_inv_quad_form_ldlt (const Eigen::Matrix< T1, R1, C1 > &D, const LDLT_factor< T2, R2, C2 > &A, const Eigen::Matrix< T3, R3, C3 > &B)
template<int RD, int CD, int RA, int CA, int RB, int CB>
double	trace_gen_quad_form (const Eigen::Matrix< double, RD, CD > &D, const Eigen::Matrix< double, RA, CA > &A, const Eigen::Matrix< double, RB, CB > &B)
template<typename T1 , typename T2 , int R2, int C2, int R3, int C3>
boost::enable_if_c< !stan::is_var< T1 >::value &&!stan::is_var< T2 >::value, typename boost::math::tools::promote_args< T1, T2 >::type >::type	trace_inv_quad_form_ldlt (const LDLT_factor< T1, R2, C2 > &A, const Eigen::Matrix< T2, R3, C3 > &B)
template<int RA, int CA, int RB, int CB>
double	trace_quad_form (const Eigen::Matrix< double, RA, CA > &A, const Eigen::Matrix< double, RB, CB > &B)
template<typename T , int R, int C>
Eigen::Matrix< T, C, R >	transpose (const Eigen::Matrix< T, R, C > &m)
template<typename T >
apply_scalar_unary< trigamma_fun, T >::return_t	trigamma (const T &x)
template<typename T >
apply_scalar_unary< trunc_fun, T >::return_t	trunc (const T &x)
template<typename T , int R, int C>
Eigen::Matrix< T, R, C >	unit_vector_constrain (const Eigen::Matrix< T, R, C > &y)
template<typename T , int R, int C>
Eigen::Matrix< T, R, C >	unit_vector_constrain (const Eigen::Matrix< T, R, C > &y, T &lp)
template<typename T >
Eigen::Matrix< T, Eigen::Dynamic, 1 >	unit_vector_free (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x)
template<typename T , int R, int C>
Eigen::Matrix< typename child_type< T >::type, R, C >	value_of (const Eigen::Matrix< T, R, C > &M)
template<int R, int C>
Eigen::Matrix< double, R, C >	value_of (const Eigen::Matrix< double, R, C > &x)
template<typename T , int R, int C>
Eigen::Matrix< double, R, C >	value_of_rec (const Eigen::Matrix< T, R, C > &M)
template<int R, int C>
Eigen::Matrix< double, R, C >	value_of_rec (const Eigen::Matrix< double, R, C > &x)
template<typename T >
boost::math::tools::promote_args< T >::type	variance (const std::vector< T > &v)
template<typename T , int R, int C>
boost::math::tools::promote_args< T >::type	variance (const Eigen::Matrix< T, R, C > &m)
template<typename F >
void	finite_diff_gradient (const F &f, const Eigen::Matrix< double,-1, 1 > &x, double &fx, Eigen::Matrix< double,-1, 1 > &grad_fx, double epsilon=1e-03)
template<typename F >
double	finite_diff_hess_helper (const F &f, const Eigen::Matrix< double, Eigen::Dynamic, 1 > &x, int lambda, double epsilon=1e-03)
template<typename F >
void	finite_diff_hessian (const F &f, const Eigen::Matrix< double,-1, 1 > &x, double &fx, Eigen::Matrix< double,-1, 1 > &grad_fx, Eigen::Matrix< double,-1,-1 > &hess_fx, double epsilon=1e-03)
template<int call_id, typename F , typename T_shared_param , typename T_job_param >
Eigen::Matrix< typename stan::return_type< T_shared_param, T_job_param >::type, Eigen::Dynamic, 1 >	map_rect (const Eigen::Matrix< T_shared_param, Eigen::Dynamic, 1 > &shared_params, const std::vector< Eigen::Matrix< T_job_param, Eigen::Dynamic, 1 >> &job_params, const std::vector< std::vector< double >> &x_r, const std::vector< std::vector< int >> &x_i, std::ostream *msgs=nullptr)
template<bool propto, typename T_n , typename T_x , typename T_beta , typename T_alpha >
return_type< T_x, T_beta, T_alpha >::type	bernoulli_logit_glm_lpmf (const T_n &n, const T_x &x, const T_beta &beta, const T_alpha &alpha)
template<typename T_n , typename T_x , typename T_beta , typename T_alpha >
return_type< T_x, T_beta, T_alpha >::type	bernoulli_logit_glm_lpmf (const T_n &n, const T_x &x, const T_beta &beta, const T_alpha &alpha)
template<bool propto, typename T_prob >
boost::math::tools::promote_args< T_prob >::type	categorical_log (int n, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &theta)
template<typename T_prob >
boost::math::tools::promote_args< T_prob >::type	categorical_log (const typename math::index_type< Eigen::VectorXd >::type n, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &theta)
template<bool propto, typename T_prob >
boost::math::tools::promote_args< T_prob >::type	categorical_log (const std::vector< int > &ns, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &theta)
template<typename T_prob >
boost::math::tools::promote_args< T_prob >::type	categorical_log (const std::vector< int > &ns, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &theta)
template<bool propto, typename T_prob >
boost::math::tools::promote_args< T_prob >::type	categorical_logit_log (int n, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &beta)
template<typename T_prob >
boost::math::tools::promote_args< T_prob >::type	categorical_logit_log (int n, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &beta)
template<bool propto, typename T_prob >
boost::math::tools::promote_args< T_prob >::type	categorical_logit_log (const std::vector< int > &ns, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &beta)
template<typename T_prob >
boost::math::tools::promote_args< T_prob >::type	categorical_logit_log (const std::vector< int > &ns, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &beta)
template<bool propto, typename T_prob >
boost::math::tools::promote_args< T_prob >::type	categorical_logit_lpmf (int n, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &beta)
template<typename T_prob >
boost::math::tools::promote_args< T_prob >::type	categorical_logit_lpmf (int n, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &beta)
template<bool propto, typename T_prob >
boost::math::tools::promote_args< T_prob >::type	categorical_logit_lpmf (const std::vector< int > &ns, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &beta)
template<typename T_prob >
boost::math::tools::promote_args< T_prob >::type	categorical_logit_lpmf (const std::vector< int > &ns, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &beta)
template<class RNG >
int	categorical_logit_rng (const Eigen::VectorXd &beta, RNG &rng)
template<bool propto, typename T_prob >
boost::math::tools::promote_args< T_prob >::type	categorical_lpmf (int n, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &theta)
template<typename T_prob >
boost::math::tools::promote_args< T_prob >::type	categorical_lpmf (const typename math::index_type< Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > >::type n, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &theta)
template<bool propto, typename T_prob >
boost::math::tools::promote_args< T_prob >::type	categorical_lpmf (const std::vector< int > &ns, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &theta)
template<typename T_prob >
boost::math::tools::promote_args< T_prob >::type	categorical_lpmf (const std::vector< int > &ns, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &theta)
template<class RNG >
int	categorical_rng (const Eigen::Matrix< double, Eigen::Dynamic, 1 > &theta, RNG &rng)
template<bool propto, typename T_prob , typename T_prior_size >
return_type< T_prob, T_prior_size >::type	dirichlet_log (const T_prob &theta, const T_prior_size &alpha)
template<typename T_prob , typename T_prior_size >
return_type< T_prob, T_prior_size >::type	dirichlet_log (const T_prob &theta, const T_prior_size &alpha)
template<bool propto, typename T_prob , typename T_prior_size >
return_type< T_prob, T_prior_size >::type	dirichlet_lpmf (const T_prob &theta, const T_prior_size &alpha)
template<typename T_prob , typename T_prior_size >
return_type< T_prob, T_prior_size >::type	dirichlet_lpmf (const T_prob &theta, const T_prior_size &alpha)
template<class RNG >
Eigen::VectorXd	dirichlet_rng (const Eigen::Matrix< double, Eigen::Dynamic, 1 > &alpha, RNG &rng)
template<bool propto, typename T_y , typename T_F , typename T_G , typename T_V , typename T_W , typename T_m0 , typename T_C0 >
return_type< T_y, typename return_type< T_F, T_G, T_V, T_W, T_m0, T_C0 >::type >::type	gaussian_dlm_obs_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_F, Eigen::Dynamic, Eigen::Dynamic > &F, const Eigen::Matrix< T_G, Eigen::Dynamic, Eigen::Dynamic > &G, const Eigen::Matrix< T_V, Eigen::Dynamic, Eigen::Dynamic > &V, const Eigen::Matrix< T_W, Eigen::Dynamic, Eigen::Dynamic > &W, const Eigen::Matrix< T_m0, Eigen::Dynamic, 1 > &m0, const Eigen::Matrix< T_C0, Eigen::Dynamic, Eigen::Dynamic > &C0)
template<typename T_y , typename T_F , typename T_G , typename T_V , typename T_W , typename T_m0 , typename T_C0 >
return_type< T_y, typename return_type< T_F, T_G, T_V, T_W, T_m0, T_C0 >::type >::type	gaussian_dlm_obs_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_F, Eigen::Dynamic, Eigen::Dynamic > &F, const Eigen::Matrix< T_G, Eigen::Dynamic, Eigen::Dynamic > &G, const Eigen::Matrix< T_V, Eigen::Dynamic, Eigen::Dynamic > &V, const Eigen::Matrix< T_W, Eigen::Dynamic, Eigen::Dynamic > &W, const Eigen::Matrix< T_m0, Eigen::Dynamic, 1 > &m0, const Eigen::Matrix< T_C0, Eigen::Dynamic, Eigen::Dynamic > &C0)
template<bool propto, typename T_y , typename T_F , typename T_G , typename T_V , typename T_W , typename T_m0 , typename T_C0 >
return_type< T_y, typename return_type< T_F, T_G, T_V, T_W, T_m0, T_C0 >::type >::type	gaussian_dlm_obs_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_F, Eigen::Dynamic, Eigen::Dynamic > &F, const Eigen::Matrix< T_G, Eigen::Dynamic, Eigen::Dynamic > &G, const Eigen::Matrix< T_V, Eigen::Dynamic, 1 > &V, const Eigen::Matrix< T_W, Eigen::Dynamic, Eigen::Dynamic > &W, const Eigen::Matrix< T_m0, Eigen::Dynamic, 1 > &m0, const Eigen::Matrix< T_C0, Eigen::Dynamic, Eigen::Dynamic > &C0)
template<typename T_y , typename T_F , typename T_G , typename T_V , typename T_W , typename T_m0 , typename T_C0 >
return_type< T_y, typename return_type< T_F, T_G, T_V, T_W, T_m0, T_C0 >::type >::type	gaussian_dlm_obs_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_F, Eigen::Dynamic, Eigen::Dynamic > &F, const Eigen::Matrix< T_G, Eigen::Dynamic, Eigen::Dynamic > &G, const Eigen::Matrix< T_V, Eigen::Dynamic, 1 > &V, const Eigen::Matrix< T_W, Eigen::Dynamic, Eigen::Dynamic > &W, const Eigen::Matrix< T_m0, Eigen::Dynamic, 1 > &m0, const Eigen::Matrix< T_C0, Eigen::Dynamic, Eigen::Dynamic > &C0)
template<bool propto, typename T_y , typename T_F , typename T_G , typename T_V , typename T_W , typename T_m0 , typename T_C0 >
return_type< T_y, typename return_type< T_F, T_G, T_V, T_W, T_m0, T_C0 >::type >::type	gaussian_dlm_obs_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_F, Eigen::Dynamic, Eigen::Dynamic > &F, const Eigen::Matrix< T_G, Eigen::Dynamic, Eigen::Dynamic > &G, const Eigen::Matrix< T_V, Eigen::Dynamic, Eigen::Dynamic > &V, const Eigen::Matrix< T_W, Eigen::Dynamic, Eigen::Dynamic > &W, const Eigen::Matrix< T_m0, Eigen::Dynamic, 1 > &m0, const Eigen::Matrix< T_C0, Eigen::Dynamic, Eigen::Dynamic > &C0)
template<typename T_y , typename T_F , typename T_G , typename T_V , typename T_W , typename T_m0 , typename T_C0 >
return_type< T_y, typename return_type< T_F, T_G, T_V, T_W, T_m0, T_C0 >::type >::type	gaussian_dlm_obs_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_F, Eigen::Dynamic, Eigen::Dynamic > &F, const Eigen::Matrix< T_G, Eigen::Dynamic, Eigen::Dynamic > &G, const Eigen::Matrix< T_V, Eigen::Dynamic, Eigen::Dynamic > &V, const Eigen::Matrix< T_W, Eigen::Dynamic, Eigen::Dynamic > &W, const Eigen::Matrix< T_m0, Eigen::Dynamic, 1 > &m0, const Eigen::Matrix< T_C0, Eigen::Dynamic, Eigen::Dynamic > &C0)
template<bool propto, typename T_y , typename T_F , typename T_G , typename T_V , typename T_W , typename T_m0 , typename T_C0 >
return_type< T_y, typename return_type< T_F, T_G, T_V, T_W, T_m0, T_C0 >::type >::type	gaussian_dlm_obs_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_F, Eigen::Dynamic, Eigen::Dynamic > &F, const Eigen::Matrix< T_G, Eigen::Dynamic, Eigen::Dynamic > &G, const Eigen::Matrix< T_V, Eigen::Dynamic, 1 > &V, const Eigen::Matrix< T_W, Eigen::Dynamic, Eigen::Dynamic > &W, const Eigen::Matrix< T_m0, Eigen::Dynamic, 1 > &m0, const Eigen::Matrix< T_C0, Eigen::Dynamic, Eigen::Dynamic > &C0)
template<typename T_y , typename T_F , typename T_G , typename T_V , typename T_W , typename T_m0 , typename T_C0 >
return_type< T_y, typename return_type< T_F, T_G, T_V, T_W, T_m0, T_C0 >::type >::type	gaussian_dlm_obs_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_F, Eigen::Dynamic, Eigen::Dynamic > &F, const Eigen::Matrix< T_G, Eigen::Dynamic, Eigen::Dynamic > &G, const Eigen::Matrix< T_V, Eigen::Dynamic, 1 > &V, const Eigen::Matrix< T_W, Eigen::Dynamic, Eigen::Dynamic > &W, const Eigen::Matrix< T_m0, Eigen::Dynamic, 1 > &m0, const Eigen::Matrix< T_C0, Eigen::Dynamic, Eigen::Dynamic > &C0)
template<bool propto, typename T_y , typename T_dof , typename T_scale >
boost::math::tools::promote_args< T_y, T_dof, T_scale >::type	inv_wishart_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &W, const T_dof &nu, const Eigen::Matrix< T_scale, Eigen::Dynamic, Eigen::Dynamic > &S)
template<typename T_y , typename T_dof , typename T_scale >
boost::math::tools::promote_args< T_y, T_dof, T_scale >::type	inv_wishart_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &W, const T_dof &nu, const Eigen::Matrix< T_scale, Eigen::Dynamic, Eigen::Dynamic > &S)
template<bool propto, typename T_y , typename T_dof , typename T_scale >
boost::math::tools::promote_args< T_y, T_dof, T_scale >::type	inv_wishart_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &W, const T_dof &nu, const Eigen::Matrix< T_scale, Eigen::Dynamic, Eigen::Dynamic > &S)
template<typename T_y , typename T_dof , typename T_scale >
boost::math::tools::promote_args< T_y, T_dof, T_scale >::type	inv_wishart_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &W, const T_dof &nu, const Eigen::Matrix< T_scale, Eigen::Dynamic, Eigen::Dynamic > &S)
template<class RNG >
Eigen::MatrixXd	inv_wishart_rng (double nu, const Eigen::MatrixXd &S, RNG &rng)
template<bool propto, typename T_covar , typename T_shape >
boost::math::tools::promote_args< T_covar, T_shape >::type	lkj_corr_cholesky_log (const Eigen::Matrix< T_covar, Eigen::Dynamic, Eigen::Dynamic > &L, const T_shape &eta)
template<typename T_covar , typename T_shape >
boost::math::tools::promote_args< T_covar, T_shape >::type	lkj_corr_cholesky_log (const Eigen::Matrix< T_covar, Eigen::Dynamic, Eigen::Dynamic > &L, const T_shape &eta)
template<bool propto, typename T_covar , typename T_shape >
boost::math::tools::promote_args< T_covar, T_shape >::type	lkj_corr_cholesky_lpdf (const Eigen::Matrix< T_covar, Eigen::Dynamic, Eigen::Dynamic > &L, const T_shape &eta)
template<typename T_covar , typename T_shape >
boost::math::tools::promote_args< T_covar, T_shape >::type	lkj_corr_cholesky_lpdf (const Eigen::Matrix< T_covar, Eigen::Dynamic, Eigen::Dynamic > &L, const T_shape &eta)
template<class RNG >
Eigen::MatrixXd	lkj_corr_cholesky_rng (size_t K, double eta, RNG &rng)
template<bool propto, typename T_y , typename T_shape >
boost::math::tools::promote_args< T_y, T_shape >::type	lkj_corr_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const T_shape &eta)
template<typename T_y , typename T_shape >
boost::math::tools::promote_args< T_y, T_shape >::type	lkj_corr_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const T_shape &eta)
template<typename T_shape >
boost::math::tools::promote_args< double, T_shape >::type	do_lkj_constant (const T_shape &eta, const unsigned int &K)
template<bool propto, typename T_y , typename T_shape >
boost::math::tools::promote_args< T_y, T_shape >::type	lkj_corr_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const T_shape &eta)
template<typename T_y , typename T_shape >
boost::math::tools::promote_args< T_y, T_shape >::type	lkj_corr_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const T_shape &eta)
template<class RNG >
Eigen::MatrixXd	lkj_corr_rng (size_t K, double eta, RNG &rng)
template<bool propto, typename T_y , typename T_loc , typename T_scale , typename T_shape >
boost::math::tools::promote_args< T_y, T_loc, T_scale, T_shape >::type	lkj_cov_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_loc, Eigen::Dynamic, 1 > &mu, const Eigen::Matrix< T_scale, Eigen::Dynamic, 1 > &sigma, const T_shape &eta)
template<typename T_y , typename T_loc , typename T_scale , typename T_shape >
boost::math::tools::promote_args< T_y, T_loc, T_scale, T_shape >::type	lkj_cov_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_loc, Eigen::Dynamic, 1 > &mu, const Eigen::Matrix< T_scale, Eigen::Dynamic, 1 > &sigma, const T_shape &eta)
template<bool propto, typename T_y , typename T_loc , typename T_scale , typename T_shape >
boost::math::tools::promote_args< T_y, T_loc, T_scale, T_shape >::type	lkj_cov_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const T_loc &mu, const T_scale &sigma, const T_shape &eta)
template<typename T_y , typename T_loc , typename T_scale , typename T_shape >
boost::math::tools::promote_args< T_y, T_loc, T_scale, T_shape >::type	lkj_cov_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const T_loc &mu, const T_scale &sigma, const T_shape &eta)
template<bool propto, typename T_y , typename T_loc , typename T_scale , typename T_shape >
boost::math::tools::promote_args< T_y, T_loc, T_scale, T_shape >::type	lkj_cov_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_loc, Eigen::Dynamic, 1 > &mu, const Eigen::Matrix< T_scale, Eigen::Dynamic, 1 > &sigma, const T_shape &eta)
template<typename T_y , typename T_loc , typename T_scale , typename T_shape >
boost::math::tools::promote_args< T_y, T_loc, T_scale, T_shape >::type	lkj_cov_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_loc, Eigen::Dynamic, 1 > &mu, const Eigen::Matrix< T_scale, Eigen::Dynamic, 1 > &sigma, const T_shape &eta)
template<bool propto, typename T_y , typename T_loc , typename T_scale , typename T_shape >
boost::math::tools::promote_args< T_y, T_loc, T_scale, T_shape >::type	lkj_cov_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const T_loc &mu, const T_scale &sigma, const T_shape &eta)
template<typename T_y , typename T_loc , typename T_scale , typename T_shape >
boost::math::tools::promote_args< T_y, T_loc, T_scale, T_shape >::type	lkj_cov_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const T_loc &mu, const T_scale &sigma, const T_shape &eta)
template<bool propto, typename T_y , typename T_Mu , typename T_Sigma , typename T_D >
boost::math::tools::promote_args< T_y, T_Mu, T_Sigma, T_D >::type	matrix_normal_prec_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_Mu, Eigen::Dynamic, Eigen::Dynamic > &Mu, const Eigen::Matrix< T_Sigma, Eigen::Dynamic, Eigen::Dynamic > &Sigma, const Eigen::Matrix< T_D, Eigen::Dynamic, Eigen::Dynamic > &D)
template<typename T_y , typename T_Mu , typename T_Sigma , typename T_D >
boost::math::tools::promote_args< T_y, T_Mu, T_Sigma, T_D >::type	matrix_normal_prec_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_Mu, Eigen::Dynamic, Eigen::Dynamic > &Mu, const Eigen::Matrix< T_Sigma, Eigen::Dynamic, Eigen::Dynamic > &Sigma, const Eigen::Matrix< T_D, Eigen::Dynamic, Eigen::Dynamic > &D)
template<bool propto, typename T_y , typename T_Mu , typename T_Sigma , typename T_D >
boost::math::tools::promote_args< T_y, T_Mu, T_Sigma, T_D >::type	matrix_normal_prec_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_Mu, Eigen::Dynamic, Eigen::Dynamic > &Mu, const Eigen::Matrix< T_Sigma, Eigen::Dynamic, Eigen::Dynamic > &Sigma, const Eigen::Matrix< T_D, Eigen::Dynamic, Eigen::Dynamic > &D)
template<typename T_y , typename T_Mu , typename T_Sigma , typename T_D >
boost::math::tools::promote_args< T_y, T_Mu, T_Sigma, T_D >::type	matrix_normal_prec_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_Mu, Eigen::Dynamic, Eigen::Dynamic > &Mu, const Eigen::Matrix< T_Sigma, Eigen::Dynamic, Eigen::Dynamic > &Sigma, const Eigen::Matrix< T_D, Eigen::Dynamic, Eigen::Dynamic > &D)
template<bool propto, typename T_y , typename T_covar , typename T_w >
boost::math::tools::promote_args< T_y, T_covar, T_w >::type	multi_gp_cholesky_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_covar, Eigen::Dynamic, Eigen::Dynamic > &L, const Eigen::Matrix< T_w, Eigen::Dynamic, 1 > &w)
template<typename T_y , typename T_covar , typename T_w >
boost::math::tools::promote_args< T_y, T_covar, T_w >::type	multi_gp_cholesky_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_covar, Eigen::Dynamic, Eigen::Dynamic > &L, const Eigen::Matrix< T_w, Eigen::Dynamic, 1 > &w)
template<bool propto, typename T_y , typename T_covar , typename T_w >
boost::math::tools::promote_args< T_y, T_covar, T_w >::type	multi_gp_cholesky_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_covar, Eigen::Dynamic, Eigen::Dynamic > &L, const Eigen::Matrix< T_w, Eigen::Dynamic, 1 > &w)
template<typename T_y , typename T_covar , typename T_w >
boost::math::tools::promote_args< T_y, T_covar, T_w >::type	multi_gp_cholesky_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_covar, Eigen::Dynamic, Eigen::Dynamic > &L, const Eigen::Matrix< T_w, Eigen::Dynamic, 1 > &w)
template<bool propto, typename T_y , typename T_covar , typename T_w >
boost::math::tools::promote_args< T_y, T_covar, T_w >::type	multi_gp_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_covar, Eigen::Dynamic, Eigen::Dynamic > &Sigma, const Eigen::Matrix< T_w, Eigen::Dynamic, 1 > &w)
template<typename T_y , typename T_covar , typename T_w >
boost::math::tools::promote_args< T_y, T_covar, T_w >::type	multi_gp_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_covar, Eigen::Dynamic, Eigen::Dynamic > &Sigma, const Eigen::Matrix< T_w, Eigen::Dynamic, 1 > &w)
template<bool propto, typename T_y , typename T_covar , typename T_w >
boost::math::tools::promote_args< T_y, T_covar, T_w >::type	multi_gp_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_covar, Eigen::Dynamic, Eigen::Dynamic > &Sigma, const Eigen::Matrix< T_w, Eigen::Dynamic, 1 > &w)
template<typename T_y , typename T_covar , typename T_w >
boost::math::tools::promote_args< T_y, T_covar, T_w >::type	multi_gp_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &y, const Eigen::Matrix< T_covar, Eigen::Dynamic, Eigen::Dynamic > &Sigma, const Eigen::Matrix< T_w, Eigen::Dynamic, 1 > &w)
template<bool propto, typename T_y , typename T_loc , typename T_covar >
return_type< T_y, T_loc, T_covar >::type	multi_normal_cholesky_log (const T_y &y, const T_loc &mu, const T_covar &L)
template<typename T_y , typename T_loc , typename T_covar >
return_type< T_y, T_loc, T_covar >::type	multi_normal_cholesky_log (const T_y &y, const T_loc &mu, const T_covar &L)
template<bool propto, typename T_y , typename T_loc , typename T_covar >
return_type< T_y, T_loc, T_covar >::type	multi_normal_cholesky_lpdf (const T_y &y, const T_loc &mu, const T_covar &L)
template<typename T_y , typename T_loc , typename T_covar >
return_type< T_y, T_loc, T_covar >::type	multi_normal_cholesky_lpdf (const T_y &y, const T_loc &mu, const T_covar &L)
template<typename T_loc , class RNG >
StdVectorBuilder< true, Eigen::VectorXd, T_loc >::type	multi_normal_cholesky_rng (const T_loc &mu, const Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > &L, RNG &rng)
template<bool propto, typename T_y , typename T_loc , typename T_covar >
return_type< T_y, T_loc, T_covar >::type	multi_normal_log (const T_y &y, const T_loc &mu, const T_covar &Sigma)
template<typename T_y , typename T_loc , typename T_covar >
return_type< T_y, T_loc, T_covar >::type	multi_normal_log (const T_y &y, const T_loc &mu, const T_covar &Sigma)
template<bool propto, typename T_y , typename T_loc , typename T_covar >
return_type< T_y, T_loc, T_covar >::type	multi_normal_lpdf (const T_y &y, const T_loc &mu, const T_covar &Sigma)
template<typename T_y , typename T_loc , typename T_covar >
return_type< T_y, T_loc, T_covar >::type	multi_normal_lpdf (const T_y &y, const T_loc &mu, const T_covar &Sigma)
template<bool propto, typename T_y , typename T_loc , typename T_covar >
return_type< T_y, T_loc, T_covar >::type	multi_normal_prec_log (const T_y &y, const T_loc &mu, const T_covar &Sigma)
template<typename T_y , typename T_loc , typename T_covar >
return_type< T_y, T_loc, T_covar >::type	multi_normal_prec_log (const T_y &y, const T_loc &mu, const T_covar &Sigma)
template<bool propto, typename T_y , typename T_loc , typename T_covar >
return_type< T_y, T_loc, T_covar >::type	multi_normal_prec_lpdf (const T_y &y, const T_loc &mu, const T_covar &Sigma)
template<typename T_y , typename T_loc , typename T_covar >
return_type< T_y, T_loc, T_covar >::type	multi_normal_prec_lpdf (const T_y &y, const T_loc &mu, const T_covar &Sigma)
template<typename T_loc , class RNG >
StdVectorBuilder< true, Eigen::VectorXd, T_loc >::type	multi_normal_rng (const T_loc &mu, const Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > &S, RNG &rng)
template<bool propto, typename T_y , typename T_dof , typename T_loc , typename T_scale >
return_type< T_y, T_dof, T_loc, T_scale >::type	multi_student_t_log (const T_y &y, const T_dof &nu, const T_loc &mu, const T_scale &Sigma)
template<typename T_y , typename T_dof , typename T_loc , typename T_scale >
return_type< T_y, T_dof, T_loc, T_scale >::type	multi_student_t_log (const T_y &y, const T_dof &nu, const T_loc &mu, const T_scale &Sigma)
template<bool propto, typename T_y , typename T_dof , typename T_loc , typename T_scale >
return_type< T_y, T_dof, T_loc, T_scale >::type	multi_student_t_lpdf (const T_y &y, const T_dof &nu, const T_loc &mu, const T_scale &Sigma)
template<typename T_y , typename T_dof , typename T_loc , typename T_scale >
return_type< T_y, T_dof, T_loc, T_scale >::type	multi_student_t_lpdf (const T_y &y, const T_dof &nu, const T_loc &mu, const T_scale &Sigma)
template<typename T_loc , class RNG >
StdVectorBuilder< true, Eigen::VectorXd, T_loc >::type	multi_student_t_rng (double nu, const T_loc &mu, const Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic > &S, RNG &rng)
template<bool propto, typename T_prob >
boost::math::tools::promote_args< T_prob >::type	multinomial_log (const std::vector< int > &ns, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &theta)
template<typename T_prob >
boost::math::tools::promote_args< T_prob >::type	multinomial_log (const std::vector< int > &ns, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &theta)
template<bool propto, typename T_prob >
boost::math::tools::promote_args< T_prob >::type	multinomial_lpmf (const std::vector< int > &ns, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &theta)
template<typename T_prob >
boost::math::tools::promote_args< T_prob >::type	multinomial_lpmf (const std::vector< int > &ns, const Eigen::Matrix< T_prob, Eigen::Dynamic, 1 > &theta)
template<class RNG >
std::vector< int >	multinomial_rng (const Eigen::Matrix< double, Eigen::Dynamic, 1 > &theta, int N, RNG &rng)
template<bool propto, typename T_n , typename T_x , typename T_beta , typename T_alpha , typename T_precision >
return_type< T_x, T_beta, T_alpha, T_precision >::type	neg_binomial_2_log_glm_lpmf (const T_n &n, const T_x &x, const T_beta &beta, const T_alpha &alpha, const T_precision &phi)
template<typename T_n , typename T_x , typename T_beta , typename T_alpha , typename T_precision >
return_type< T_x, T_beta, T_alpha, T_precision >::type	neg_binomial_2_log_glm_lpmf (const T_n &n, const T_x &x, const T_beta &beta, const T_alpha &alpha, const T_precision &phi)
template<bool propto, typename T_n , typename T_x , typename T_beta , typename T_alpha , typename T_scale >
return_type< T_n, T_x, T_beta, T_alpha, T_scale >::type	normal_id_glm_lpdf (const T_n &n, const T_x &x, const T_beta &beta, const T_alpha &alpha, const T_scale &sigma)
template<typename T_n , typename T_x , typename T_beta , typename T_alpha , typename T_scale >
return_type< T_n, T_x, T_beta, T_alpha, T_scale >::type	normal_id_glm_lpdf (const T_n &n, const T_x &x, const T_beta &beta, const T_alpha &alpha, const T_scale &sigma)
template<bool propto, typename T_y , typename T_loc , typename T_cut >
return_type< T_loc, T_cut >::type	ordered_logistic_log (const T_y &y, const T_loc &lambda, const T_cut &c)
template<typename T_y , typename T_loc , typename T_cut >
return_type< T_loc, T_cut >::type	ordered_logistic_log (const T_y &y, const T_loc &lambda, const T_cut &c)
template<bool propto, typename T_loc , typename T_cut >
return_type< T_loc, T_cut >::type	ordered_logistic_lpmf (int y, const T_loc &lambda, const Eigen::Matrix< T_cut, Eigen::Dynamic, 1 > &c)
template<typename T_loc , typename T_cut >
return_type< T_loc, T_cut >::type	ordered_logistic_lpmf (int y, const T_loc &lambda, const Eigen::Matrix< T_cut, Eigen::Dynamic, 1 > &c)
template<bool propto, typename T_loc , typename T_cut >
return_type< T_loc, T_cut >::type	ordered_logistic_lpmf (const std::vector< int > &y, const Eigen::Matrix< T_loc, Eigen::Dynamic, 1 > &lambda, const Eigen::Matrix< T_cut, Eigen::Dynamic, 1 > &c)
template<typename T_loc , typename T_cut >
return_type< T_loc, T_cut >::type	ordered_logistic_lpmf (const std::vector< int > &y, const Eigen::Matrix< T_loc, Eigen::Dynamic, 1 > &lambda, const Eigen::Matrix< T_cut, Eigen::Dynamic, 1 > &c)
template<bool propto, typename T_loc , typename T_cut >
return_type< T_loc, T_cut >::type	ordered_logistic_lpmf (const std::vector< int > &y, const Eigen::Matrix< T_loc, Eigen::Dynamic, 1 > &lambda, const std::vector< Eigen::Matrix< T_cut, Eigen::Dynamic, 1 > > &c)
template<typename T_loc , typename T_cut >
return_type< T_loc, T_cut >::type	ordered_logistic_lpmf (const std::vector< int > &y, const Eigen::Matrix< T_loc, Eigen::Dynamic, 1 > &lambda, const std::vector< Eigen::Matrix< T_cut, Eigen::Dynamic, 1 > > &c)
template<class RNG >
int	ordered_logistic_rng (double eta, const Eigen::Matrix< double, Eigen::Dynamic, 1 > &c, RNG &rng)
template<bool propto, typename T_y , typename T_loc , typename T_cut >
return_type< T_loc, T_cut >::type	ordered_probit_log (const T_y &y, const T_loc &lambda, const T_cut &c)
template<typename T_y , typename T_loc , typename T_cut >
return_type< T_loc, T_cut >::type	ordered_probit_log (const T_y &y, const T_loc &lambda, const T_cut &c)
template<bool propto, typename T_loc , typename T_cut >
return_type< T_loc, T_cut >::type	ordered_probit_lpmf (int y, const T_loc &lambda, const Eigen::Matrix< T_cut, Eigen::Dynamic, 1 > &c)
template<typename T_loc , typename T_cut >
return_type< T_loc, T_cut >::type	ordered_probit_lpmf (int y, const T_loc &lambda, const Eigen::Matrix< T_cut, Eigen::Dynamic, 1 > &c)
template<bool propto, typename T_loc , typename T_cut >
return_type< T_loc, T_cut >::type	ordered_probit_lpmf (const std::vector< int > &y, const Eigen::Matrix< T_loc, Eigen::Dynamic, 1 > &lambda, const Eigen::Matrix< T_cut, Eigen::Dynamic, 1 > &c)
template<typename T_loc , typename T_cut >
return_type< T_loc, T_cut >::type	ordered_probit_lpmf (const std::vector< int > &y, const Eigen::Matrix< T_loc, Eigen::Dynamic, 1 > &lambda, const Eigen::Matrix< T_cut, Eigen::Dynamic, 1 > &c)
template<bool propto, typename T_loc , typename T_cut >
return_type< T_loc, T_cut >::type	ordered_probit_lpmf (const std::vector< int > &y, const Eigen::Matrix< T_loc, Eigen::Dynamic, 1 > &lambda, const std::vector< Eigen::Matrix< T_cut, Eigen::Dynamic, 1 > > &c)
template<typename T_loc , typename T_cut >
return_type< T_loc, T_cut >::type	ordered_probit_lpmf (const std::vector< int > &y, const Eigen::Matrix< T_loc, Eigen::Dynamic, 1 > &lambda, const std::vector< Eigen::Matrix< T_cut, Eigen::Dynamic, 1 > > &c)
template<class RNG >
int	ordered_probit_rng (double eta, const Eigen::VectorXd &c, RNG &rng)
template<bool propto, typename T_n , typename T_x , typename T_beta , typename T_alpha >
return_type< T_x, T_beta, T_alpha >::type	poisson_log_glm_lpmf (const T_n &n, const T_x &x, const T_beta &beta, const T_alpha &alpha)
template<typename T_n , typename T_x , typename T_beta , typename T_alpha >
return_type< T_x, T_beta, T_alpha >::type	poisson_log_glm_lpmf (const T_n &n, const T_x &x, const T_beta &beta, const T_alpha &alpha)
template<bool propto, typename T_y , typename T_dof , typename T_scale >
boost::math::tools::promote_args< T_y, T_dof, T_scale >::type	wishart_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &W, const T_dof &nu, const Eigen::Matrix< T_scale, Eigen::Dynamic, Eigen::Dynamic > &S)
template<typename T_y , typename T_dof , typename T_scale >
boost::math::tools::promote_args< T_y, T_dof, T_scale >::type	wishart_log (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &W, const T_dof &nu, const Eigen::Matrix< T_scale, Eigen::Dynamic, Eigen::Dynamic > &S)
template<bool propto, typename T_y , typename T_dof , typename T_scale >
boost::math::tools::promote_args< T_y, T_dof, T_scale >::type	wishart_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &W, const T_dof &nu, const Eigen::Matrix< T_scale, Eigen::Dynamic, Eigen::Dynamic > &S)
template<typename T_y , typename T_dof , typename T_scale >
boost::math::tools::promote_args< T_y, T_dof, T_scale >::type	wishart_lpdf (const Eigen::Matrix< T_y, Eigen::Dynamic, Eigen::Dynamic > &W, const T_dof &nu, const Eigen::Matrix< T_scale, Eigen::Dynamic, Eigen::Dynamic > &S)
template<class RNG >
Eigen::MatrixXd	wishart_rng (double nu, const Eigen::MatrixXd &S, RNG &rng)
template<typename T_a1 , typename T_a2 , typename T_b1 , typename T_z >
void	check_2F1_converges (const char *function, const T_a1 &a1, const T_a2 &a2, const T_b1 &b1, const T_z &z)
template<typename T_a1 , typename T_a2 , typename T_a3 , typename T_b1 , typename T_b2 , typename T_z >
void	check_3F2_converges (const char *function, const T_a1 &a1, const T_a2 &a2, const T_a3 &a3, const T_b1 &b1, const T_b2 &b2, const T_z &z)
template<typename T_y , typename T_low , typename T_high >
void	check_bounded (const char *function, const char *name, const T_y &y, const T_low &low, const T_high &high)
template<typename T >
void	check_consistent_size (const char *function, const char *name, const T &x, size_t expected_size)
template<typename T1 , typename T2 >
void	check_consistent_sizes (const char *function, const char *name1, const T1 &x1, const char *name2, const T2 &x2)
template<typename T1 , typename T2 , typename T3 >
void	check_consistent_sizes (const char *function, const char *name1, const T1 &x1, const char *name2, const T2 &x2, const char *name3, const T3 &x3)
template<typename T1 , typename T2 , typename T3 , typename T4 >
void	check_consistent_sizes (const char *function, const char *name1, const T1 &x1, const char *name2, const T2 &x2, const char *name3, const T3 &x3, const char *name4, const T4 &x4)
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
void	check_consistent_sizes (const char *function, const char *name1, const T1 &x1, const char *name2, const T2 &x2, const char *name3, const T3 &x3, const char *name4, const T4 &x4, const char *name5, const T5 &x5)
template<typename T_y >
void	check_finite (const char *function, const char *name, const T_y &y)
template<typename T_y , typename T_low >
void	check_greater (const char *function, const char *name, const T_y &y, const T_low &low)
template<typename T_y , typename T_low >
void	check_greater_or_equal (const char *function, const char *name, const T_y &y, const T_low &low)
template<typename T_y , typename T_high >
void	check_less (const char *function, const char *name, const T_y &y, const T_high &high)
template<typename T_y , typename T_high >
void	check_less_or_equal (const char *function, const char *name, const T_y &y, const T_high &high)
template<typename T_y >
void	check_nonnegative (const char *function, const char *name, const T_y &y)
template<typename T_y >
void	check_not_nan (const char *function, const char *name, const T_y &y)
template<typename T_y >
void	check_positive (const char *function, const char *name, const T_y &y)
template<typename T_y >
void	check_positive_finite (const char *function, const char *name, const T_y &y)
void	check_positive_size (const char *function, const char *name, const char *expr, int size)
template<typename T_size1 , typename T_size2 >
void	check_size_match (const char *function, const char *name_i, T_size1 i, const char *name_j, T_size2 j)
template<typename T_size1 , typename T_size2 >
void	check_size_match (const char *function, const char *expr_i, const char *name_i, T_size1 i, const char *expr_j, const char *name_j, T_size2 j)
template<typename T >
void	domain_error (const char *function, const char *name, const T &y, const char *msg1, const char *msg2)
template<typename T >
void	domain_error (const char *function, const char *name, const T &y, const char *msg1)
template<typename T >
void	domain_error_vec (const char *function, const char *name, const T &y, size_t i, const char *msg1, const char *msg2)
template<typename T >
void	domain_error_vec (const char *function, const char *name, const T &y, size_t i, const char *msg)
template<typename T >
void	invalid_argument (const char *function, const char *name, const T &y, const char *msg1, const char *msg2)
template<typename T >
void	invalid_argument (const char *function, const char *name, const T &y, const char *msg1)
template<typename T >
void	invalid_argument_vec (const char *function, const char *name, const T &y, size_t i, const char *msg1, const char *msg2)
template<typename T >
void	invalid_argument_vec (const char *function, const char *name, const T &y, size_t i, const char *msg)
void	out_of_range (const char *function, int max, int index, const char *msg1="", const char *msg2="")
void	system_error (const char *function, const char *name, const int &y, const char *msg1, const char *msg2)
void	system_error (const char *function, const char *name, const int &y, const char *msg1)
double	abs (double x)
double	acosh (double x)
double	acosh (int x)
template<typename T >
bool	as_bool (const T &x)
double	asinh (double x)
double	asinh (int x)
double	atanh (double x)
double	atanh (int x)
template<typename T2 >
T2	bessel_first_kind (int v, const T2 z)
template<typename T2 >
T2	bessel_second_kind (int v, const T2 z)
template<typename T >
T	binary_log_loss (int y, const T &y_hat)
template<typename T_N , typename T_n >
boost::math::tools::promote_args< T_N, T_n >::type	binomial_coefficient_log (const T_N N, const T_n n)
double	cbrt (double x)
double	cbrt (int x)
int	choose (int n, int k)
double	pi ()
double	e ()
double	sqrt2 ()
double	log10 ()
double	positive_infinity ()
double	negative_infinity ()
double	not_a_number ()
double	machine_precision ()
template<typename T >
T	corr_constrain (const T &x)
template<typename T >
T	corr_constrain (const T &x, T &lp)
template<typename T >
T	corr_free (const T &y)
double	digamma (double x)
template<typename T1 , typename T2 >
return_type< T1, T2 >::type	distance (const T1 &x1, const T2 &x2)
template<typename T1 , typename T2 >
stan::return_type< T1, T2 >::type	divide (const T1 &x, const T2 &y)
int	divide (int x, int y)
double	erf (double x)
double	erf (int x)
double	erfc (double x)
double	erfc (int x)
double	exp (int x)
double	exp2 (double y)
double	exp2 (int y)
double	expm1 (double x)
double	expm1 (int x)
template<typename T >
T	F32 (const T &a1, const T &a2, const T &a3, const T &b1, const T &b2, const T &z, double precision=1e-6, int max_steps=1e5)
template<typename T >
boost::math::tools::promote_args< T >::type	falling_factorial (const T &x, int n)
template<typename T1 , typename T2 >
boost::math::tools::promote_args< T1, T2 >::type	fdim (T1 x, T2 y)
template<typename T , typename S >
void	fill (T &x, const S &y)
template<typename T1 , typename T2 , typename T3 >
boost::math::tools::promote_args< T1, T2, T3 >::type	fma (const T1 &x, const T2 &y, const T3 &z)
template<typename T1 , typename T2 >
boost::math::tools::promote_args< T1, T2 >::type	fmax (const T1 &x, const T2 &y)
template<typename T1 , typename T2 >
boost::math::tools::promote_args< T1, T2 >::type	fmin (const T1 &x, const T2 &y)
double	gamma_p (double x, double a)
double	gamma_q (double x, double a)
template<typename T >
void	grad_2F1 (T &g_a1, T &g_b1, const T &a1, const T &a2, const T &b1, const T &z, const T &precision=1e-10, int max_steps=1e5)
template<typename T >
void	grad_F32 (T *g, const T &a1, const T &a2, const T &a3, const T &b1, const T &b2, const T &z, const T &precision=1e-6, int max_steps=1e5)
void	grad_inc_beta (double &g1, double &g2, double a, double b, double z)
template<typename T >
void	grad_reg_inc_beta (T &g1, T &g2, const T &a, const T &b, const T &z, const T &digammaA, const T &digammaB, const T &digammaSum, const T &betaAB)
template<typename T1 , typename T2 >
return_type< T1, T2 >::type	grad_reg_inc_gamma (T1 a, T2 z, T1 g, T1 dig, double precision=1e-6, int max_steps=1e5)
template<typename T1 , typename T2 >
return_type< T1, T2 >::type	grad_reg_lower_inc_gamma (const T1 &a, const T2 &z, double precision=1e-10, int max_steps=1e5)
template<typename T1 , typename T2 >
boost::math::tools::promote_args< T1, T2 >::type	hypot (const T1 &x, const T2 &y)
double	ibeta (double a, double b, double x)
template<typename T >
T	identity_constrain (const T &x)
template<typename T >
T	identity_constrain (const T &x, T &)
template<typename T >
T	identity_free (const T &y)
template<typename T_true , typename T_false >
boost::math::tools::promote_args< T_true, T_false >::type	if_else (const bool c, const T_true y_true, const T_false y_false)
double	inc_beta (double a, double b, double x)
template<typename T >
T	inc_beta_dda (T a, T b, T z, T digamma_a, T digamma_ab)
template<typename T >
T	inc_beta_ddb (T a, T b, T z, T digamma_b, T digamma_ab)
template<typename T >
T	inc_beta_ddz (T a, T b, T z)
template<>
double	inc_beta_ddz (double a, double b, double z)
template<typename T >
int	int_step (const T &y)
double	inv (double x)
double	inv_cloglog (double x)
double	inv_logit (double a)
double	inv_Phi (double p)
double	inv_sqrt (double x)
double	inv_square (double x)
int	is_inf (double x)
template<typename T >
bool	is_integer (T x)
bool	is_nan (double x)
template<typename T >
bool	is_nonpositive_integer (T x)
template<typename T >
bool	is_uninitialized (T x)
template<typename T , typename L >
T	lb_constrain (const T &x, const L &lb)
template<typename T , typename L >
boost::math::tools::promote_args< T, L >::type	lb_constrain (const T &x, const L &lb, T &lp)
template<typename T , typename L >
boost::math::tools::promote_args< T, L >::type	lb_free (const T &y, const L &lb)
template<typename T1 , typename T2 >
boost::math::tools::promote_args< T1, T2 >::type	lbeta (const T1 a, const T2 b)
template<typename T >
T	ldexp (const T &a, int b)
double	lgamma (double x)
double	lgamma (int x)
template<typename T >
boost::math::tools::promote_args< T >::type	lmgamma (int k, T x)
double	log (int x)
double	log1m (double x)
double	log1m_exp (double a)
double	log1m_inv_logit (double u)
double	log1m_inv_logit (int u)
double	log1p (double x)
double	log1p (int x)
double	log1p_exp (double a)
double	log2 (double u)
double	log2 (int u)
double	log2 ()
template<typename T1 , typename T2 >
boost::math::tools::promote_args< T1, T2 >::type	log_diff_exp (const T1 x, const T2 y)
template<typename T1 , typename T2 >
boost::math::tools::promote_args< T1, T2 >::type	log_falling_factorial (const T1 x, const T2 n)
double	log_inv_logit (double u)
double	log_inv_logit (int u)
template<typename T1 , typename T2 >
boost::math::tools::promote_args< T1, T2 >::type	log_inv_logit_diff (const T1 &x, const T2 &y)
double	log_mix (double theta, double lambda1, double lambda2)
template<typename T1 , typename T2 >
boost::math::tools::promote_args< T1, T2, double >::type	log_modified_bessel_first_kind (const T1 v, const T2 z)
template<typename T1 , typename T2 >
boost::math::tools::promote_args< T1, T2 >::type	log_rising_factorial (const T1 &x, const T2 &n)
template<typename T1 , typename T2 >
boost::math::tools::promote_args< T1, T2 >::type	log_sum_exp (const T2 &a, const T1 &b)
template<typename T1 , typename T2 >
int	logical_and (const T1 x1, const T2 x2)
template<typename T1 , typename T2 >
int	logical_eq (const T1 x1, const T2 x2)
template<typename T1 , typename T2 >
int	logical_gt (const T1 x1, const T2 x2)
template<typename T1 , typename T2 >
int	logical_gte (const T1 x1, const T2 x2)
template<typename T1 , typename T2 >
int	logical_lt (T1 x1, T2 x2)
template<typename T1 , typename T2 >
int	logical_lte (const T1 x1, const T2 x2)
template<typename T >
int	logical_negation (const T &x)
template<typename T1 , typename T2 >
int	logical_neq (const T1 x1, const T2 x2)
template<typename T1 , typename T2 >
int	logical_or (T1 x1, T2 x2)
double	logit (double u)
double	logit (int u)
template<typename T , typename L , typename U >
boost::math::tools::promote_args< T, L, U >::type	lub_constrain (const T &x, const L &lb, const U &ub)
template<typename T , typename L , typename U >
boost::math::tools::promote_args< T, L, U >::type	lub_constrain (const T &x, const L &lb, const U &ub, T &lp)
template<typename T , typename L , typename U >
boost::math::tools::promote_args< T, L, U >::type	lub_free (const T &y, const L &lb, const U &ub)
template<typename T2 >
T2	modified_bessel_first_kind (int v, const T2 z)
template<typename T2 >
T2	modified_bessel_second_kind (int v, const T2 z)
int	modulus (int x, int y)
template<typename T_a , typename T_b >
boost::math::tools::promote_args< T_a, T_b >::type	multiply_log (const T_a a, const T_b b)
double	owens_t (double h, double a)
double	Phi (double x)
double	Phi_approx (double x)
double	Phi_approx (int x)
template<typename T >
T	positive_constrain (const T &x)
template<typename T >
T	positive_constrain (const T &x, T &lp)
template<typename T >
T	positive_free (const T &y)
template<typename T >
boost::enable_if< boost::is_arithmetic< T >, T >::type	primitive_value (T x)
template<typename T >
boost::disable_if< boost::is_arithmetic< T >, double >::type	primitive_value (const T &x)
template<typename T >
T	prob_constrain (const T &x)
template<typename T >
T	prob_constrain (const T &x, T &lp)
template<typename T >
T	prob_free (const T &y)
template<typename T , typename S >
promote_scalar_type< T, S >::type	promote_scalar (const S &x)
template<typename T >
boost::math::tools::promote_args< T >::type	rising_factorial (const T &x, int n)
double	round (double x)
double	round (int x)
template<typename T >
int	sign (const T &z)
template<typename T >
bool	size_zero (T &x)
template<typename T , typename... Ts>
bool	size_zero (T &x, Ts &&...xs)
double	square (double x)
template<typename T1 , typename T2 >
boost::math::tools::promote_args< T1, T2 >::type	squared_distance (const T1 &x1, const T2 &x2)
template<typename T >
double	step (const T &y)
double	tgamma (double x)
template<typename T >
T	trigamma_impl (const T &x)
double	trigamma (double u)
double	trigamma (int u)
double	trunc (double x)
double	trunc (int x)
template<typename T , typename U >
boost::math::tools::promote_args< T, U >::type	ub_constrain (const T &x, const U &ub)
template<typename T , typename U >
boost::math::tools::promote_args< T, U >::type	ub_constrain (const T &x, const U &ub, T &lp)
template<typename T , typename U >
boost::math::tools::promote_args< T, U >::type	ub_free (const T &y, const U &ub)
template<typename T >
double	value_of (const T x)
template<>
double	value_of< double > (double x)
template<typename T >
double	value_of_rec (const T x)
template<>
double	value_of_rec< double > (double x)
template<typename T_n , typename T_prob >
return_type< T_prob >::type	bernoulli_ccdf_log (const T_n &n, const T_prob &theta)
template<typename T_n , typename T_prob >
return_type< T_prob >::type	bernoulli_cdf (const T_n &n, const T_prob &theta)
template<typename T_n , typename T_prob >
return_type< T_prob >::type	bernoulli_cdf_log (const T_n &n, const T_prob &theta)
template<typename T_n , typename T_prob >
return_type< T_prob >::type	bernoulli_lccdf (const T_n &n, const T_prob &theta)
template<typename T_n , typename T_prob >
return_type< T_prob >::type	bernoulli_lcdf (const T_n &n, const T_prob &theta)
template<bool propto, typename T_n , typename T_prob >
return_type< T_prob >::type	bernoulli_log (const T_n &n, const T_prob &theta)
template<typename T_y , typename T_prob >
return_type< T_prob >::type	bernoulli_log (const T_y &n, const T_prob &theta)
template<bool propto, typename T_n , typename T_prob >
return_type< T_prob >::type	bernoulli_logit_log (const T_n &n, const T_prob &theta)
template<typename T_n , typename T_prob >
return_type< T_prob >::type	bernoulli_logit_log (const T_n &n, const T_prob &theta)
template<bool propto, typename T_n , typename T_prob >
return_type< T_prob >::type	bernoulli_logit_lpmf (const T_n &n, const T_prob &theta)
template<typename T_n , typename T_prob >
return_type< T_prob >::type	bernoulli_logit_lpmf (const T_n &n, const T_prob &theta)
template<class RNG >
int	bernoulli_logit_rng (double t, RNG &rng)
template<bool propto, typename T_n , typename T_prob >
return_type< T_prob >::type	bernoulli_lpmf (const T_n &n, const T_prob &theta)
template<typename T_y , typename T_prob >
return_type< T_prob >::type	bernoulli_lpmf (const T_y &n, const T_prob &theta)
template<typename T_theta , class RNG >
VectorBuilder< true, int, T_theta >::type	bernoulli_rng (const T_theta &theta, RNG &rng)
template<typename T_n , typename T_N , typename T_size1 , typename T_size2 >
return_type< T_size1, T_size2 >::type	beta_binomial_ccdf_log (const T_n &n, const T_N &N, const T_size1 &alpha, const T_size2 &beta)
template<typename T_n , typename T_N , typename T_size1 , typename T_size2 >
return_type< T_size1, T_size2 >::type	beta_binomial_cdf (const T_n &n, const T_N &N, const T_size1 &alpha, const T_size2 &beta)
template<typename T_n , typename T_N , typename T_size1 , typename T_size2 >
return_type< T_size1, T_size2 >::type	beta_binomial_cdf_log (const T_n &n, const T_N &N, const T_size1 &alpha, const T_size2 &beta)
template<typename T_n , typename T_N , typename T_size1 , typename T_size2 >
return_type< T_size1, T_size2 >::type	beta_binomial_lccdf (const T_n &n, const T_N &N, const T_size1 &alpha, const T_size2 &beta)
template<typename T_n , typename T_N , typename T_size1 , typename T_size2 >
return_type< T_size1, T_size2 >::type	beta_binomial_lcdf (const T_n &n, const T_N &N, const T_size1 &alpha, const T_size2 &beta)
template<bool propto, typename T_n , typename T_N , typename T_size1 , typename T_size2 >
return_type< T_size1, T_size2 >::type	beta_binomial_log (const T_n &n, const T_N &N, const T_size1 &alpha, const T_size2 &beta)
template<typename T_n , typename T_N , typename T_size1 , typename T_size2 >
return_type< T_size1, T_size2 >::type	beta_binomial_log (const T_n &n, const T_N &N, const T_size1 &alpha, const T_size2 &beta)
template<bool propto, typename T_n , typename T_N , typename T_size1 , typename T_size2 >
return_type< T_size1, T_size2 >::type	beta_binomial_lpmf (const T_n &n, const T_N &N, const T_size1 &alpha, const T_size2 &beta)
template<typename T_n , typename T_N , typename T_size1 , typename T_size2 >
return_type< T_size1, T_size2 >::type	beta_binomial_lpmf (const T_n &n, const T_N &N, const T_size1 &alpha, const T_size2 &beta)
template<typename T_N , typename T_shape1 , typename T_shape2 , class RNG >
VectorBuilder< true, int, T_N, T_shape1, T_shape2 >::type	beta_binomial_rng (const T_N &N, const T_shape1 &alpha, const T_shape2 &beta, RNG &rng)
template<typename T_y , typename T_scale_succ , typename T_scale_fail >
return_type< T_y, T_scale_succ, T_scale_fail >::type	beta_ccdf_log (const T_y &y, const T_scale_succ &alpha, const T_scale_fail &beta)
template<typename T_y , typename T_scale_succ , typename T_scale_fail >
return_type< T_y, T_scale_succ, T_scale_fail >::type	beta_cdf (const T_y &y, const T_scale_succ &alpha, const T_scale_fail &beta)
template<typename T_y , typename T_scale_succ , typename T_scale_fail >
return_type< T_y, T_scale_succ, T_scale_fail >::type	beta_cdf_log (const T_y &y, const T_scale_succ &alpha, const T_scale_fail &beta)
template<typename T_y , typename T_scale_succ , typename T_scale_fail >
return_type< T_y, T_scale_succ, T_scale_fail >::type	beta_lccdf (const T_y &y, const T_scale_succ &alpha, const T_scale_fail &beta)
template<typename T_y , typename T_scale_succ , typename T_scale_fail >
return_type< T_y, T_scale_succ, T_scale_fail >::type	beta_lcdf (const T_y &y, const T_scale_succ &alpha, const T_scale_fail &beta)
template<bool propto, typename T_y , typename T_scale_succ , typename T_scale_fail >
return_type< T_y, T_scale_succ, T_scale_fail >::type	beta_log (const T_y &y, const T_scale_succ &alpha, const T_scale_fail &beta)
template<typename T_y , typename T_scale_succ , typename T_scale_fail >
return_type< T_y, T_scale_succ, T_scale_fail >::type	beta_log (const T_y &y, const T_scale_succ &alpha, const T_scale_fail &beta)
template<bool propto, typename T_y , typename T_scale_succ , typename T_scale_fail >
return_type< T_y, T_scale_succ, T_scale_fail >::type	beta_lpdf (const T_y &y, const T_scale_succ &alpha, const T_scale_fail &beta)
template<typename T_y , typename T_scale_succ , typename T_scale_fail >
return_type< T_y, T_scale_succ, T_scale_fail >::type	beta_lpdf (const T_y &y, const T_scale_succ &alpha, const T_scale_fail &beta)
template<typename T_shape1 , typename T_shape2 , class RNG >
VectorBuilder< true, double, T_shape1, T_shape2 >::type	beta_rng (const T_shape1 &alpha, const T_shape2 &beta, RNG &rng)
template<typename T_n , typename T_N , typename T_prob >
return_type< T_prob >::type	binomial_ccdf_log (const T_n &n, const T_N &N, const T_prob &theta)
template<typename T_n , typename T_N , typename T_prob >
return_type< T_prob >::type	binomial_cdf (const T_n &n, const T_N &N, const T_prob &theta)
template<typename T_n , typename T_N , typename T_prob >
return_type< T_prob >::type	binomial_cdf_log (const T_n &n, const T_N &N, const T_prob &theta)
template<typename T_n , typename T_N , typename T_prob >
return_type< T_prob >::type	binomial_lccdf (const T_n &n, const T_N &N, const T_prob &theta)
template<typename T_n , typename T_N , typename T_prob >
return_type< T_prob >::type	binomial_lcdf (const T_n &n, const T_N &N, const T_prob &theta)
template<bool propto, typename T_n , typename T_N ,