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