Namespaces | Classes | Typedefs | Functions | Variables
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_allocChainableStack
 
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< Tlog_sum_exp (const std::vector< fvar< T > > &v)
 
template<typename T >
fvar< Tsum (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< Toperator+ (const fvar< T > &x1, const fvar< T > &x2)
 
template<typename T >
fvar< Toperator+ (double x1, const fvar< T > &x2)
 
template<typename T >
fvar< Toperator+ (const fvar< T > &x1, double x2)
 
template<typename T >
fvar< Toperator/ (const fvar< T > &x1, const fvar< T > &x2)
 
template<typename T >
fvar< Toperator/ (const fvar< T > &x1, double x2)
 
template<typename T >
fvar< Toperator/ (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< Toperator* (const fvar< T > &x, const fvar< T > &y)
 
template<typename T >
fvar< Toperator* (double x, const fvar< T > &y)
 
template<typename T >
fvar< Toperator* (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< Toperator- (const fvar< T > &x1, const fvar< T > &x2)
 
template<typename T >
fvar< Toperator- (double x1, const fvar< T > &x2)
 
template<typename T >
fvar< Toperator- (const fvar< T > &x1, double x2)
 
template<typename T >
fvar< Toperator- (const fvar< T > &x)
 
template<typename T >
bool operator! (const fvar< T > &x)
 
template<typename T >
fvar< Toperator+ (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, Ccolumns_dot_self (const Eigen::Matrix< fvar< T >, R, C > &x)
 
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, C, Ccrossprod (const Eigen::Matrix< fvar< T >, R, C > &m)
 
template<typename T , int R, int C>
fvar< Tdeterminant (const Eigen::Matrix< fvar< T >, R, C > &m)
 
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, Cdivide (const Eigen::Matrix< fvar< T >, R, C > &v, const fvar< T > &c)
 
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, Cdivide (const Eigen::Matrix< fvar< T >, R, C > &v, double c)
 
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, Cdivide (const Eigen::Matrix< double, R, C > &v, const fvar< T > &c)
 
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, Coperator/ (const Eigen::Matrix< fvar< T >, R, C > &v, const fvar< T > &c)
 
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, Coperator/ (const Eigen::Matrix< fvar< T >, R, C > &v, double c)
 
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, Coperator/ (const Eigen::Matrix< double, R, C > &v, const fvar< T > &c)
 
template<typename T , int R1, int C1, int R2, int C2>
fvar< Tdot_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< Tdot_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< Tdot_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< Tdot_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< Tdot_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< Tdot_product (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< fvar< T >, R2, C2 > &v2, size_type &length)
 
template<typename T >
fvar< Tdot_product (const std::vector< fvar< T > > &v1, const std::vector< fvar< T > > &v2)
 
template<typename T >
fvar< Tdot_product (const std::vector< double > &v1, const std::vector< fvar< T > > &v2)
 
template<typename T >
fvar< Tdot_product (const std::vector< fvar< T > > &v1, const std::vector< double > &v2)
 
template<typename T >
fvar< Tdot_product (const std::vector< fvar< T > > &v1, const std::vector< fvar< T > > &v2, size_type &length)
 
template<typename T >
fvar< Tdot_product (const std::vector< double > &v1, const std::vector< fvar< T > > &v2, size_type &length)
 
template<typename T >
fvar< Tdot_product (const std::vector< fvar< T > > &v1, const std::vector< double > &v2, size_type &length)
 
template<typename T , int R, int C>
fvar< Tdot_self (const Eigen::Matrix< fvar< T >, R, C > &v)
 
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, Cinverse (const Eigen::Matrix< fvar< T >, R, C > &m)
 
template<typename T , int R, int C>
fvar< Tlog_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< Tlog_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< Tmultiply (const Eigen::Matrix< fvar< T >, 1, C1 > &rv, const Eigen::Matrix< fvar< T >, R2, 1 > &v)
 
template<typename T , int C1, int R2>
fvar< Tmultiply (const Eigen::Matrix< fvar< T >, 1, C1 > &rv, const Eigen::Matrix< double, R2, 1 > &v)
 
template<typename T , int C1, int R2>
fvar< Tmultiply (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, Rmultiply_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< Tquad_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< Tquad_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< Tsquared_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< Tsquared_distance (const Eigen::Matrix< fvar< T >, R1, C1 > &v1, const Eigen::Matrix< double, R2, C2 > &v2)
 
template<typename T , int R, int C>
fvar< Tsquared_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< Tsquared_distance (const Eigen::Matrix< double, R1, C1 > &v1, const Eigen::Matrix< fvar< T >, R2, C2 > &v2)
 
template<typename T , int R, int C>
fvar< Tsquared_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< Tsquared_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< Tsum (const Eigen::Matrix< fvar< T >, R, C > &m)
 
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, Rtcrossprod (const Eigen::Matrix< fvar< T >, R, C > &m)
 
template<int R, int C, typename T >
Eigen::Matrix< T, R, Cto_fvar (const Eigen::Matrix< T, R, C > &m)
 
template<int R, int C>
Eigen::Matrix< fvar< double >, R, Cto_fvar (const Eigen::Matrix< double, R, C > &m)
 
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, Cto_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< Ttrace_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< Ttrace_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< Ttrace_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< Ttrace_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, Cunit_vector_constrain (const Eigen::Matrix< fvar< T >, R, C > &y)
 
template<typename T , int R, int C>
Eigen::Matrix< fvar< T >, R, Cunit_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< Tabs (const fvar< T > &x)
 
template<typename T >
fvar< Tacos (const fvar< T > &x)
 
template<typename T >
fvar< Tacosh (const fvar< T > &x)
 
template<typename T >
fvar< Tasin (const fvar< T > &x)
 
template<typename T >
fvar< Tasinh (const fvar< T > &x)
 
template<typename T >
fvar< Tatan (const fvar< T > &x)
 
template<typename T >
fvar< Tatan2 (const fvar< T > &x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tatan2 (double x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tatan2 (const fvar< T > &x1, double x2)
 
template<typename T >
fvar< Tatanh (const fvar< T > &x)
 
template<typename T >
fvar< Tbessel_first_kind (int v, const fvar< T > &z)
 
template<typename T >
fvar< Tbessel_second_kind (int v, const fvar< T > &z)
 
template<typename T >
fvar< Tbinary_log_loss (int y, const fvar< T > &y_hat)
 
template<typename T >
fvar< Tbinomial_coefficient_log (const fvar< T > &x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tbinomial_coefficient_log (const fvar< T > &x1, double x2)
 
template<typename T >
fvar< Tbinomial_coefficient_log (double x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tcbrt (const fvar< T > &x)
 
template<typename T >
fvar< Tceil (const fvar< T > &x)
 
template<typename T >
fvar< Tcos (const fvar< T > &x)
 
template<typename T >
fvar< Tcosh (const fvar< T > &x)
 
template<typename T >
fvar< Tdigamma (const fvar< T > &x)
 
template<typename T >
fvar< Terf (const fvar< T > &x)
 
template<typename T >
fvar< Terfc (const fvar< T > &x)
 
template<typename T >
fvar< Texp (const fvar< T > &x)
 
template<typename T >
fvar< Texp2 (const fvar< T > &x)
 
template<typename T >
fvar< Texpm1 (const fvar< T > &x)
 
template<typename T >
fvar< Tfabs (const fvar< T > &x)
 
template<typename T >
fvar< Tfalling_factorial (const fvar< T > &x, int n)
 
template<typename T >
fvar< Tfdim (const fvar< T > &x, const fvar< T > &y)
 
template<typename T >
fvar< Tfdim (const fvar< T > &x, double y)
 
template<typename T >
fvar< Tfdim (double x, const fvar< T > &y)
 
template<typename T >
fvar< Tfloor (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< Tfmax (const fvar< T > &x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tfmax (double x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tfmax (const fvar< T > &x1, double x2)
 
template<typename T >
fvar< Tfmin (const fvar< T > &x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tfmin (double x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tfmin (const fvar< T > &x1, double x2)
 
template<typename T >
fvar< Tfmod (const fvar< T > &x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tfmod (const fvar< T > &x1, double x2)
 
template<typename T >
fvar< Tfmod (double x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tgamma_p (const fvar< T > &x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tgamma_p (const fvar< T > &x1, double x2)
 
template<typename T >
fvar< Tgamma_p (double x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tgamma_q (const fvar< T > &x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tgamma_q (const fvar< T > &x1, double x2)
 
template<typename T >
fvar< Tgamma_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< Thypot (const fvar< T > &x1, const fvar< T > &x2)
 
template<typename T >
fvar< Thypot (const fvar< T > &x1, double x2)
 
template<typename T >
fvar< Thypot (double x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tinc_beta (const fvar< T > &a, const fvar< T > &b, const fvar< T > &x)
 
template<typename T >
fvar< Tinv (const fvar< T > &x)
 
template<typename T >
fvar< Tinv_cloglog (const fvar< T > &x)
 
template<typename T >
fvar< Tinv_logit (const fvar< T > &x)
 
template<typename T >
fvar< Tinv_Phi (const fvar< T > &p)
 
template<typename T >
fvar< Tinv_sqrt (const fvar< T > &x)
 
template<typename T >
fvar< Tinv_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< Tlbeta (const fvar< T > &x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tlbeta (double x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tlbeta (const fvar< T > &x1, double x2)
 
template<typename T >
fvar< Tlgamma (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< Tlog (const fvar< T > &x)
 
template<typename T >
fvar< Tlog10 (const fvar< T > &x)
 
template<typename T >
fvar< Tlog1m (const fvar< T > &x)
 
template<typename T >
fvar< Tlog1m_exp (const fvar< T > &x)
 
template<typename T >
fvar< Tlog1m_inv_logit (const fvar< T > &x)
 
template<typename T >
fvar< Tlog1p (const fvar< T > &x)
 
template<typename T >
fvar< Tlog1p_exp (const fvar< T > &x)
 
template<typename T >
fvar< Tlog2 (const fvar< T > &x)
 
template<typename T >
fvar< Tlog_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< Tlog_falling_factorial (const fvar< T > &x, const fvar< T > &n)
 
template<typename T >
fvar< Tlog_falling_factorial (double x, const fvar< T > &n)
 
template<typename T >
fvar< Tlog_falling_factorial (const fvar< T > &x, double n)
 
template<typename T >
fvar< Tlog_inv_logit (const fvar< T > &x)
 
template<typename T >
fvar< Tlog_inv_logit_diff (const fvar< T > &x, const fvar< T > &y)
 
template<typename T >
fvar< Tlog_inv_logit_diff (const fvar< T > &x, double y)
 
template<typename T >
fvar< Tlog_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< Tlog_mix (const fvar< T > &theta, const fvar< T > &lambda1, const fvar< T > &lambda2)
 
template<typename T >
fvar< Tlog_mix (const fvar< T > &theta, const fvar< T > &lambda1, double lambda2)
 
template<typename T >
fvar< Tlog_mix (const fvar< T > &theta, double lambda1, const fvar< T > &lambda2)
 
template<typename T >
fvar< Tlog_mix (double theta, const fvar< T > &lambda1, const fvar< T > &lambda2)
 
template<typename T >
fvar< Tlog_mix (const fvar< T > &theta, double lambda1, double lambda2)
 
template<typename T >
fvar< Tlog_mix (double theta, const fvar< T > &lambda1, double lambda2)
 
template<typename T >
fvar< Tlog_mix (double theta, double lambda1, const fvar< T > &lambda2)
 
template<typename T >
fvar< Tlog_rising_factorial (const fvar< T > &x, const fvar< T > &n)
 
template<typename T >
fvar< Tlog_rising_factorial (const fvar< T > &x, double n)
 
template<typename T >
fvar< Tlog_rising_factorial (double x, const fvar< T > &n)
 
template<typename T >
fvar< Tlog_sum_exp (const fvar< T > &x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tlog_sum_exp (double x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tlog_sum_exp (const fvar< T > &x1, double x2)
 
template<typename T >
fvar< Tlogit (const fvar< T > &x)
 
template<typename T >
fvar< Tmodified_bessel_first_kind (int v, const fvar< T > &z)
 
template<typename T >
fvar< Tmodified_bessel_second_kind (int v, const fvar< T > &z)
 
template<typename T >
fvar< Tmultiply_log (const fvar< T > &x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tmultiply_log (double x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tmultiply_log (const fvar< T > &x1, double x2)
 
template<typename T >
fvar< Towens_t (const fvar< T > &x1, const fvar< T > &x2)
 
template<typename T >
fvar< Towens_t (double x1, const fvar< T > &x2)
 
template<typename T >
fvar< Towens_t (const fvar< T > &x1, double x2)
 
template<typename T >
fvar< TPhi (const fvar< T > &x)
 
template<typename T >
fvar< TPhi_approx (const fvar< T > &x)
 
template<typename T >
fvar< Tpow (const fvar< T > &x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tpow (double x1, const fvar< T > &x2)
 
template<typename T >
fvar< Tpow (const fvar< T > &x1, double x2)
 
template<typename T >
double primitive_value (const fvar< T > &v)
 
template<typename T >
fvar< Trising_factorial (const fvar< T > &x, int n)
 
template<typename T >
fvar< Tround (const fvar< T > &x)
 
template<typename T >
fvar< Tsin (const fvar< T > &x)
 
template<typename T >
fvar< Tsinh (const fvar< T > &x)
 
template<typename T >
fvar< Tsqrt (const fvar< T > &x)
 
template<typename T >
fvar< Tsquare (const fvar< T > &x)
 
template<typename T >
fvar< Ttan (const fvar< T > &x)
 
template<typename T >
fvar< Ttanh (const fvar< T > &x)
 
template<typename T >
fvar< Ttgamma (const fvar< T > &x)
 
template<typename T >
fvar< Tto_fvar (const T &x)
 
template<typename T >
fvar< Tto_fvar (const fvar< T > &x)
 
template<typename T >
fvar< Ttrigamma (const fvar< T > &u)
 
template<typename T >
fvar< Ttrunc (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< Trep_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< Tsort_asc (std::vector< T > xs)
 
template<typename T >
std::vector< Tsort_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, Cadd (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, Cadd (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, Cadd (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, Ccolumns_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< intcsr_extract_u (const Eigen::SparseMatrix< T, Eigen::RowMajor > &A)
 
template<typename T , int R, int C>
const std::vector< intcsr_extract_u (const Eigen::Matrix< T, R, C > &A)
 
template<typename T >
const std::vector< intcsr_extract_v (const Eigen::SparseMatrix< T, Eigen::RowMajor > &A)
 
template<typename T , int R, int C>
const std::vector< intcsr_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< Tcumulative_sum (const std::vector< T > &x)
 
template<typename T , int R, int C>
Eigen::Matrix< T, R, Ccumulative_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< intdims (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, Celt_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, Celt_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, Celt_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, Celt_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 Tget_base1 (const std::vector< T > &x, size_t i, const char *error_msg, size_t idx)
 
template<typename T >
const Tget_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 Tget_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 Tget_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 Tget_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 Tget_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 Tget_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 Tget_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 Tget_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 Tget_base1 (const Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, size_t m, const char *error_msg, size_t idx)
 
template<typename T >
const Tget_base1 (const Eigen::Matrix< T, 1, Eigen::Dynamic > &x, size_t n, const char *error_msg, size_t idx)
 
template<typename T >
Tget_base1_lhs (std::vector< T > &x, size_t i, const char *error_msg, size_t idx)
 
template<typename T >
Tget_base1_lhs (std::vector< std::vector< T > > &x, size_t i1, size_t i2, const char *error_msg, size_t idx)
 
template<typename T >
Tget_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 >
Tget_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 >
Tget_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 >
Tget_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 >
Tget_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 >
Tget_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 >
Tget_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 >
Tget_base1_lhs (Eigen::Matrix< T, Eigen::Dynamic, 1 > &x, size_t m, const char *error_msg, size_t idx)
 
template<typename T >
Tget_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< Thead (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, Cinverse (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< Tsegment (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, Csort_asc (Eigen::Matrix< T, R, C > xs)
 
template<typename T , int R, int C>
Eigen::Matrix< T, R, Csort_desc (Eigen::Matrix< T, R, C > xs)
 
template<typename C >
std::vector< intsort_indices_asc (const C &xs)
 
template<typename C >
std::vector< intsort_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, Csubtract (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, Csubtract (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, Csubtract (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< Ttail (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< Tto_array_1d (const Eigen::Matrix< T, R, C > &matrix)
 
template<typename T >
std::vector< Tto_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, Rtranspose (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, Cunit_vector_constrain (const Eigen::Matrix< T, R, C > &y)
 
template<typename T , int R, int C>
Eigen::Matrix< T, R, Cunit_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, Cvalue_of (const Eigen::Matrix< T, R, C > &M)
 
template<int R, int C>
Eigen::Matrix< double, R, Cvalue_of (const Eigen::Matrix< double, R, C > &x)
 
template<typename T , int R, int C>
Eigen::Matrix< double, R, Cvalue_of_rec (const Eigen::Matrix< T, R, C > &M)
 
template<int R, int C>
Eigen::Matrix< double, R, Cvalue_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< intmultinomial_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 , typename T_prob >
return_type< T_prob >::type binomial_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_log (const T_n &n, const T_N &N, const T_prob &theta)
 
template<bool propto, typename T_n , typename T_N , typename T_prob >
return_type< T_prob >::type binomial_logit_log (const T_n &n, const T_N &N, const T_prob &alpha)
 
template<typename T_n , typename T_N , typename T_prob >
return_type< T_prob >::type binomial_logit_log (const T_n &n, const T_N &N, const T_prob &alpha)
 
template<bool propto, typename T_n , typename T_N , typename T_prob >
return_type< T_prob >::type binomial_logit_lpmf (const T_n &n, const T_N &N, const T_prob &alpha)
 
template<typename T_n , typename T_N , typename T_prob >
return_type< T_prob >::type binomial_logit_lpmf (const T_n &n, const T_N &N, const T_prob &alpha)
 
template<bool propto, typename T_n , typename T_N , typename T_prob >
return_type< T_prob >::type binomial_lpmf (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_lpmf (const T_n &n, const T_N &N, const T_prob &theta)
 
template<typename T_N , typename T_theta , class RNG >
VectorBuilder< true, int, T_N, T_theta >::type binomial_rng (const T_N &N, const T_theta &theta, RNG &rng)
 
template<typename T_y , typename T_loc , typename T_scale >
return_type< T_y, T_loc, T_scale >::type cauchy_ccdf_log (const T_y &y, const T_loc &mu, const T_scale &sigma)
 
template<typename T_y , typename T_loc , typename T_scale >
return_type< T_y, T_loc, T_scale >::type cauchy_cdf (const T_y &y, const T_loc &mu, const T_scale &sigma)
 
template<typename T_y , typename T_loc , typename T_scale >
return_type< T_y, T_loc, T_scale >::type cauchy_cdf_log (const T_y &y, const T_loc &mu, const T_scale &sigma)
 
template<typename T_y , typename T_loc , typename T_scale >
return_type< T_y, T_loc, T_scale >::type cauchy_lccdf (const T_y &y, const T_loc &mu, const T_scale &sigma)
 
template<typename T_y , typename T_loc , typename T_scale >
return_type< T_y, T_loc, T_scale >::type cauchy_lcdf (const T_y &y, const T_loc &mu, const T_scale &sigma)
 
template<bool propto, typename T_y , typename T_loc , typename T_scale >
return_type< T_y, T_loc, T_scale >::type cauchy_log (const T_y &y, const T_loc &mu, const T_scale &sigma)
 
template<typename T_y , typename T_loc , typename T_scale >
return_type< T_y, T_loc, T_scale >::type cauchy_log (const T_y &y, const T_loc &mu, const T_scale &sigma)
 
template<bool propto, typename T_y , typename T_loc , typename T_scale >
return_type< T_y, T_loc, T_scale >::type cauchy_lpdf (const T_y &y, const T_loc &mu, const T_scale &sigma)
 
template<typename T_y , typename T_loc , typename T_scale >
return_type< T_y, T_loc, T_scale >::type cauchy_lpdf (const T_y &y, const T_loc &mu, const T_scale &sigma)
 
template<typename T_loc , typename T_scale , class RNG >
VectorBuilder< true, double, T_loc, T_scale >::type cauchy_rng (const T_loc &mu, const T_scale &sigma, RNG &rng)
 
template<typename T_y , typename T_dof >
return_type< T_y, T_dof >::type chi_square_ccdf_log (const T_y &y, const T_dof &nu)
 
template<typename T_y , typename T_dof >
return_type< T_y, T_dof >::type chi_square_cdf (const T_y &y, const T_dof &nu)
 
template<typename T_y , typename T_dof >
return_type< T_y, T_dof >::type chi_square_cdf_log (const T_y &y, const T_dof &nu)
 
template<typename T_y , typename T_dof >
return_type< T_y, T_dof >::type chi_square_lccdf (const T_y &y, const T_dof &nu)
 
template<typename T_y , typename T_dof >
return_type< T_y, T_dof >::type chi_square_lcdf (const T_y &y, const T_dof &nu)
 
template<bool propto, typename T_y , typename T_dof >
return_type< T_y, T_dof >::type chi_square_log (const T_y &y, const T_dof &nu)
 
template<typename T_y , typename T_dof >
return_type< T_y, T_dof >::type chi_square_log (const T_y &y, const T_dof &nu)
 
template<bool propto, typename T_y , typename T_dof >
return_type< T_y, T_dof >::type chi_square_lpdf (const T_y &y, const T_dof &nu)
 
template<typename T_y , typename T_dof >
return_type< T_y, T_dof >::type chi_square_lpdf (const T_y &y, const T_dof &nu)
 
template<typename T_deg , class RNG >
VectorBuilder< true, double, T_deg >::type chi_square_rng (const T_deg &nu, RNG &rng)
 
template<typename T_y , typename T_loc , typename T_scale >