├── .github ├── FUNDING.yml └── workflows │ └── test.yml ├── .gitignore ├── .gitmodules ├── .travis.yml ├── COPYING ├── Makefile ├── README.md ├── ac-stan ├── Cask ├── Makefile ├── README.md ├── ac-dict │ └── stan-mode ├── ac-stan.el ├── create_ac_dict.py ├── example_auto_completion.png └── test-ac-stan.el ├── common.mk ├── company-stan ├── Cask ├── Makefile ├── README.md ├── company-stan.el ├── example_completion.png └── test-company-stan.el ├── eldoc-stan ├── Cask ├── Makefile ├── README.md ├── eldoc-stan-create-json.el ├── eldoc-stan.el ├── eldoc-stan.json ├── example_eldoc.png ├── test-eldoc-stan-create-json.el └── test-eldoc-stan.el ├── example.el ├── example.gif ├── example.png ├── example_schools_mod_ncp.stan ├── flycheck-stan ├── .gitignore ├── Cask ├── Makefile ├── README.md ├── error_msgs.txt ├── example_flycheck.png ├── examples │ ├── 01_example_error_number_model_name.stan │ ├── 01_example_error_number_model_name.stanc3out.txt │ ├── 01_example_error_number_model_name.stancout.txt │ ├── example_error_and_info_composite.stan │ ├── example_error_and_info_composite.stanc3out.txt │ ├── example_error_and_info_composite.stancout.txt │ ├── example_error_and_info_misspelled_type.stan │ ├── example_error_and_info_misspelled_type.stanc3out.txt │ ├── example_error_and_info_misspelled_type.stancout.txt │ ├── example_error_and_info_not_conditional.stan │ ├── example_error_and_info_not_conditional.stanc3out.txt │ ├── example_error_and_info_not_conditional.stancout.txt │ ├── example_error_and_info_undefined_function.stan │ ├── example_error_and_info_undefined_function.stanc3out.txt │ ├── example_error_and_info_undefined_function.stancout.txt │ ├── example_error_and_info_undefined_include_file.stan │ ├── example_error_and_info_undefined_include_file.stanc3out.txt │ ├── example_error_and_info_undefined_include_file.stancout.txt │ ├── example_error_and_info_undefined_variable.stan │ ├── example_error_and_info_undefined_variable.stanc3out.txt │ ├── example_error_and_info_undefined_variable.stancout.txt │ ├── example_error_invalid_character.stan │ ├── example_error_invalid_character.stanc3out.txt │ ├── example_error_invalid_character.stancout.txt │ ├── example_error_misspelled_type.stan │ ├── example_error_misspelled_type.stanc3out.txt │ ├── example_error_misspelled_type.stancout.txt │ ├── example_error_not_conditional.stan │ ├── example_error_not_conditional.stanc3out.txt │ ├── example_error_not_conditional.stancout.txt │ ├── example_error_undefined_function.stan │ ├── example_error_undefined_function.stanc3out.txt │ ├── example_error_undefined_function.stancout.txt │ ├── example_error_undefined_include_file.stan │ ├── example_error_undefined_include_file.stanc3out.txt │ ├── example_error_undefined_include_file.stancout.txt │ ├── example_error_undefined_variable.stan │ ├── example_error_undefined_variable.stanc3out.txt │ ├── example_error_undefined_variable.stancout.txt │ ├── example_failure_and_info_misspelled_block.stan │ ├── example_failure_and_info_misspelled_block.stanc3out.txt │ ├── example_failure_and_info_misspelled_block.stancout.txt │ ├── example_failure_misspelled_block.stan │ ├── example_failure_misspelled_block.stanc3out.txt │ ├── example_failure_misspelled_block.stancout.txt │ ├── example_info_composite.stan │ ├── example_info_composite.stanc3out.txt │ ├── example_info_composite.stancout.txt │ ├── example_info_composite_with_error.stan │ ├── example_info_composite_with_error.stanc3out.txt │ ├── example_info_composite_with_error.stancout.txt │ ├── example_info_deprecated_assignment.stan │ ├── example_info_deprecated_assignment.stanc3out.txt │ ├── example_info_deprecated_assignment.stancout.txt │ ├── example_info_deprecated_comments.stan │ ├── example_info_deprecated_comments.stanc3out.txt │ ├── example_info_deprecated_comments.stancout.txt │ ├── example_info_deprecated_functions.stan │ ├── example_info_deprecated_functions.stanc3out.txt │ ├── example_info_deprecated_functions.stancout.txt │ ├── example_info_jacobian.stan │ ├── example_info_jacobian.stanc3out.txt │ ├── example_info_jacobian.stancout.txt │ ├── example_ok.stan │ ├── example_ok.stanc3out.txt │ └── example_ok.stancout.txt ├── flycheck-stan-error-msgs.el ├── flycheck-stan.el ├── semantic_actions_def.cpp ├── test-flycheck-stan-error-msgs.el └── test-flycheck-stan.el ├── indent-stan-files ├── Cask ├── Makefile ├── README.md └── indent-stan-files ├── stan-mode ├── Cask ├── Makefile ├── README.md ├── create_stan_keywords.py ├── stan-keywords.el ├── stan-mode.el ├── test-c++-mode.el └── test-stan-mode.el ├── stan-snippets ├── Cask ├── Makefile ├── README.md ├── create_snippets.py ├── example_snippet.png ├── snippets │ └── stan-mode │ │ ├── .yas-make-groups │ │ ├── .yas-parents │ │ ├── cholesky_factor_corr.yasnippet │ │ ├── cholesky_factor_cov.yasnippet │ │ ├── corr_matrix.yasnippet │ │ ├── cov_matrix.yasnippet │ │ ├── data.yasnippet │ │ ├── elif.yasnippet │ │ ├── else.yasnippet │ │ ├── for.yasnippet │ │ ├── fun.yasnippet │ │ ├── functions.yasnippet │ │ ├── functions │ │ ├── Phi(x).yasnippet │ │ ├── Phi_approx(x).yasnippet │ │ ├── abs(x).yasnippet │ │ ├── acos(x).yasnippet │ │ ├── acosh(x).yasnippet │ │ ├── add_diag(m,d).yasnippet │ │ ├── algebra_solver(algebra_system,y_guess,theta,x_r,x_i).yasnippet │ │ ├── algebra_solver(algebra_system,y_guess,theta,x_r,x_i,rel_tol,f_tol,max_steps).yasnippet │ │ ├── append_array(x,y).yasnippet │ │ ├── append_col(x,y).yasnippet │ │ ├── append_row(x,y).yasnippet │ │ ├── asin(x).yasnippet │ │ ├── asinh(x).yasnippet │ │ ├── atan(x).yasnippet │ │ ├── atan2(y,x).yasnippet │ │ ├── atanh(x).yasnippet │ │ ├── bernoulli(theta).yasnippet │ │ ├── bernoulli_cdf(y,theta).yasnippet │ │ ├── bernoulli_lccdf(y,theta).yasnippet │ │ ├── bernoulli_lcdf(y,theta).yasnippet │ │ ├── bernoulli_logit(alpha).yasnippet │ │ ├── bernoulli_logit_glm(x,alpha,beta).yasnippet │ │ ├── bernoulli_logit_glm_lpmf(y,x,alpha,beta).yasnippet │ │ ├── bernoulli_logit_lpmf(y,alpha).yasnippet │ │ ├── bernoulli_logit_rng(alpha).yasnippet │ │ ├── bernoulli_lpmf(y,theta).yasnippet │ │ ├── bernoulli_rng(theta).yasnippet │ │ ├── bessel_first_kind(v,x).yasnippet │ │ ├── bessel_second_kind(v,x).yasnippet │ │ ├── beta(alpha,beta).yasnippet │ │ ├── beta_binomial(N,alpha,beta).yasnippet │ │ ├── beta_binomial_cdf(n,N,alpha,beta).yasnippet │ │ ├── beta_binomial_lccdf(n,N,alpha,beta).yasnippet │ │ ├── beta_binomial_lcdf(n,N,alpha,beta).yasnippet │ │ ├── beta_binomial_lpmf(n,N,alpha,beta).yasnippet │ │ ├── beta_binomial_rng(N,alpha,beta).yasnippet │ │ ├── beta_cdf(theta,alpha,beta).yasnippet │ │ ├── beta_lccdf(theta,alpha,beta).yasnippet │ │ ├── beta_lcdf(theta,alpha,beta).yasnippet │ │ ├── beta_lpdf(theta,alpha,beta).yasnippet │ │ ├── beta_proportion_lccdf(theta,mu,kappa).yasnippet │ │ ├── beta_proportion_lcdf(theta,mu,kappa).yasnippet │ │ ├── beta_proportion_rng(mu,kappa).yasnippet │ │ ├── beta_rng(alpha,beta).yasnippet │ │ ├── binary_log_loss(y,y_hat).yasnippet │ │ ├── binomial(N,theta).yasnippet │ │ ├── binomial_cdf(n,N,theta).yasnippet │ │ ├── binomial_coefficient_log(x,y).yasnippet │ │ ├── binomial_lccdf(n,N,theta).yasnippet │ │ ├── binomial_lcdf(n,N,theta).yasnippet │ │ ├── binomial_logit(N,alpha).yasnippet │ │ ├── binomial_logit_lpmf(n,N,alpha).yasnippet │ │ ├── binomial_lpmf(n,N,theta).yasnippet │ │ ├── binomial_rng(N,theta).yasnippet │ │ ├── block(x,i,j,n_rows,n_cols).yasnippet │ │ ├── categorical(theta).yasnippet │ │ ├── categorical_logit(beta).yasnippet │ │ ├── categorical_logit_glm(theta).yasnippet │ │ ├── categorical_logit_glm(x,alpha,beta).yasnippet │ │ ├── categorical_logit_glm_lpmf(y,theta).yasnippet │ │ ├── categorical_logit_glm_lpmf(y,x,alpha,beta).yasnippet │ │ ├── categorical_logit_lpmf(y,beta).yasnippet │ │ ├── categorical_logit_rng(beta).yasnippet │ │ ├── categorical_lpmf(y,theta).yasnippet │ │ ├── categorical_rng(theta).yasnippet │ │ ├── cauchy(mu,sigma).yasnippet │ │ ├── cauchy_cdf(y,mu,sigma).yasnippet │ │ ├── cauchy_lccdf(y,mu,sigma).yasnippet │ │ ├── cauchy_lcdf(y,mu,sigma).yasnippet │ │ ├── cauchy_lpdf(y,mu,sigma).yasnippet │ │ ├── cauchy_rng(mu,sigma).yasnippet │ │ ├── cbrt(x).yasnippet │ │ ├── ceil(x).yasnippet │ │ ├── chi_square(nu).yasnippet │ │ ├── chi_square_cdf(y,nu).yasnippet │ │ ├── chi_square_lccdf(y,nu).yasnippet │ │ ├── chi_square_lcdf(y,nu).yasnippet │ │ ├── chi_square_lpdf(y,nu).yasnippet │ │ ├── chi_square_rng(nu).yasnippet │ │ ├── cholesky_decompose(A).yasnippet │ │ ├── choose(x,y).yasnippet │ │ ├── col(x,n).yasnippet │ │ ├── cols(x).yasnippet │ │ ├── columns_dot_product(x,y).yasnippet │ │ ├── columns_dot_self(x).yasnippet │ │ ├── cos(x).yasnippet │ │ ├── cosh(x).yasnippet │ │ ├── cov_exp_quad(x,alpha,rho).yasnippet │ │ ├── cov_exp_quad(x1,x2,alpha,rho).yasnippet │ │ ├── crossprod(x).yasnippet │ │ ├── csr_extract_u(a).yasnippet │ │ ├── csr_extract_v(a).yasnippet │ │ ├── csr_extract_w(a).yasnippet │ │ ├── csr_matrix_times_vector(m,n,w,v,u,b).yasnippet │ │ ├── csr_to_dense_matrix(m,n,w,v,u).yasnippet │ │ ├── cumulative_sum(rv).yasnippet │ │ ├── cumulative_sum(v).yasnippet │ │ ├── cumulative_sum(x).yasnippet │ │ ├── determinant(A).yasnippet │ │ ├── diag_matrix(x).yasnippet │ │ ├── diag_post_multiply(m,rv).yasnippet │ │ ├── diag_post_multiply(m,v).yasnippet │ │ ├── diag_pre_multiply(rv,m).yasnippet │ │ ├── diag_pre_multiply(v,m).yasnippet │ │ ├── diagonal(x).yasnippet │ │ ├── digamma(x).yasnippet │ │ ├── dims(x).yasnippet │ │ ├── dirichlet(alpha).yasnippet │ │ ├── dirichlet_lpdf(theta,alpha).yasnippet │ │ ├── dirichlet_rng(alpha).yasnippet │ │ ├── distance(x,y).yasnippet │ │ ├── dot_product(x,y).yasnippet │ │ ├── dot_self(x).yasnippet │ │ ├── double_exponential(mu,sigma).yasnippet │ │ ├── double_exponential_cdf(y,mu,sigma).yasnippet │ │ ├── double_exponential_lccdf(y,mu,sigma).yasnippet │ │ ├── double_exponential_lcdf(y,mu,sigma).yasnippet │ │ ├── double_exponential_lpdf(y,mu,sigma).yasnippet │ │ ├── double_exponential_rng(mu,sigma).yasnippet │ │ ├── eigenvalues_sym(A).yasnippet │ │ ├── eigenvectors_sym(A).yasnippet │ │ ├── erf(x).yasnippet │ │ ├── erfc(x).yasnippet │ │ ├── exp(x).yasnippet │ │ ├── exp2(x).yasnippet │ │ ├── exp_mod_normal(mu,sigma,lambda).yasnippet │ │ ├── exp_mod_normal_cdf(y,mu,sigma,lambda).yasnippet │ │ ├── exp_mod_normal_lccdf(y,mu,sigma,lambda).yasnippet │ │ ├── exp_mod_normal_lcdf(y,mu,sigma,lambda).yasnippet │ │ ├── exp_mod_normal_lpdf(y,mu,sigma,lambda).yasnippet │ │ ├── exp_mod_normal_rng(mu,sigma,lambda).yasnippet │ │ ├── expm1(x).yasnippet │ │ ├── exponential(beta).yasnippet │ │ ├── exponential_cdf(y,beta).yasnippet │ │ ├── exponential_lccdf(y,beta).yasnippet │ │ ├── exponential_lcdf(y,beta).yasnippet │ │ ├── exponential_lpdf(y,beta).yasnippet │ │ ├── exponential_rng(beta).yasnippet │ │ ├── fabs(x).yasnippet │ │ ├── falling_factorial(x,n).yasnippet │ │ ├── fdim(x,y).yasnippet │ │ ├── floor(x).yasnippet │ │ ├── fma(x,y,z).yasnippet │ │ ├── fmax(x,y).yasnippet │ │ ├── fmin(x,y).yasnippet │ │ ├── fmod(x,y).yasnippet │ │ ├── frechet(alpha,sigma).yasnippet │ │ ├── frechet_cdf(y,alpha,sigma).yasnippet │ │ ├── frechet_lccdf(y,alpha,sigma).yasnippet │ │ ├── frechet_lcdf(y,alpha,sigma).yasnippet │ │ ├── frechet_lpdf(y,alpha,sigma).yasnippet │ │ ├── frechet_rng(alpha,sigma).yasnippet │ │ ├── gamma(alpha,beta).yasnippet │ │ ├── gamma_cdf(y,alpha,beta).yasnippet │ │ ├── gamma_lccdf(y,alpha,beta).yasnippet │ │ ├── gamma_lcdf(y,alpha,beta).yasnippet │ │ ├── gamma_lpdf(y,alpha,beta).yasnippet │ │ ├── gamma_p(a,z).yasnippet │ │ ├── gamma_q(a,z).yasnippet │ │ ├── gamma_rng(alpha,beta).yasnippet │ │ ├── gaussian_dlm_obs(F,G,V,W,m0,C0).yasnippet │ │ ├── gaussian_dlm_obs_lpdf(y,F,G,V,W,m0,C0).yasnippet │ │ ├── gumbel(mu,beta).yasnippet │ │ ├── gumbel_cdf(y,mu,beta).yasnippet │ │ ├── gumbel_lccdf(y,mu,beta).yasnippet │ │ ├── gumbel_lcdf(y,mu,beta).yasnippet │ │ ├── gumbel_lpdf(y,mu,beta).yasnippet │ │ ├── gumbel_rng(mu,beta).yasnippet │ │ ├── head(rv,n).yasnippet │ │ ├── head(sv,n).yasnippet │ │ ├── head(v,n).yasnippet │ │ ├── hypergeometric(N,a,b).yasnippet │ │ ├── hypergeometric_lpmf(n,N,a,b).yasnippet │ │ ├── hypergeometric_rng(N,a,b).yasnippet │ │ ├── hypot(x,y).yasnippet │ │ ├── inc_beta(alpha,beta,x).yasnippet │ │ ├── int_step(x).yasnippet │ │ ├── integrate_1d(integrand,a,b,theta,x_r,x_i).yasnippet │ │ ├── integrate_1d(integrand,a,b,theta,x_r,x_i,relative_tolerance).yasnippet │ │ ├── inv(x).yasnippet │ │ ├── inv_Phi(x).yasnippet │ │ ├── inv_chi_square(nu).yasnippet │ │ ├── inv_chi_square_cdf(y,nu).yasnippet │ │ ├── inv_chi_square_lccdf(y,nu).yasnippet │ │ ├── inv_chi_square_lcdf(y,nu).yasnippet │ │ ├── inv_chi_square_lpdf(y,nu).yasnippet │ │ ├── inv_chi_square_rng(nu).yasnippet │ │ ├── inv_cloglog(x).yasnippet │ │ ├── inv_gamma(alpha,beta).yasnippet │ │ ├── inv_gamma_cdf(y,alpha,beta).yasnippet │ │ ├── inv_gamma_lccdf(y,alpha,beta).yasnippet │ │ ├── inv_gamma_lcdf(y,alpha,beta).yasnippet │ │ ├── inv_gamma_lpdf(y,alpha,beta).yasnippet │ │ ├── inv_gamma_rng(alpha,beta).yasnippet │ │ ├── inv_logit(x).yasnippet │ │ ├── inv_sqrt(x).yasnippet │ │ ├── inv_square(x).yasnippet │ │ ├── inv_wishart(nu,Sigma).yasnippet │ │ ├── inv_wishart_lpdf(W,nu,Sigma).yasnippet │ │ ├── inv_wishart_rng(nu,Sigma).yasnippet │ │ ├── inverse(A).yasnippet │ │ ├── inverse_spd(A).yasnippet │ │ ├── is_inf(x).yasnippet │ │ ├── is_nan(x).yasnippet │ │ ├── lbeta(alpha,beta).yasnippet │ │ ├── lchoose(x,y).yasnippet │ │ ├── lgamma(x).yasnippet │ │ ├── lkj_corr(eta).yasnippet │ │ ├── lkj_corr_cholesky(eta).yasnippet │ │ ├── lkj_corr_cholesky_lpdf(L,eta).yasnippet │ │ ├── lkj_corr_cholesky_rng(K,eta).yasnippet │ │ ├── lkj_corr_lpdf(y,eta).yasnippet │ │ ├── lkj_corr_rng(K,eta).yasnippet │ │ ├── lmgamma(n,x).yasnippet │ │ ├── lmultiply(x,y).yasnippet │ │ ├── log(x).yasnippet │ │ ├── log10(x).yasnippet │ │ ├── log1m(x).yasnippet │ │ ├── log1m_exp(x).yasnippet │ │ ├── log1m_inv_logit(x).yasnippet │ │ ├── log1p(x).yasnippet │ │ ├── log1p_exp(x).yasnippet │ │ ├── log2(x).yasnippet │ │ ├── log_determinant(A).yasnippet │ │ ├── log_diff_exp(x,y).yasnippet │ │ ├── log_falling_factorial(x,n).yasnippet │ │ ├── log_inv_logit(x).yasnippet │ │ ├── log_mix(theta,lp1,lp2).yasnippet │ │ ├── log_rising_factorial(x,n).yasnippet │ │ ├── log_softmax(x).yasnippet │ │ ├── log_sum_exp(x).yasnippet │ │ ├── log_sum_exp(x,y).yasnippet │ │ ├── logistic(mu,sigma).yasnippet │ │ ├── logistic_cdf(y,mu,sigma).yasnippet │ │ ├── logistic_lccdf(y,mu,sigma).yasnippet │ │ ├── logistic_lcdf(y,mu,sigma).yasnippet │ │ ├── logistic_lpdf(y,mu,sigma).yasnippet │ │ ├── logistic_rng(mu,sigma).yasnippet │ │ ├── logit(x).yasnippet │ │ ├── lognormal(mu,sigma).yasnippet │ │ ├── lognormal_cdf(y,mu,sigma).yasnippet │ │ ├── lognormal_lccdf(y,mu,sigma).yasnippet │ │ ├── lognormal_lcdf(y,mu,sigma).yasnippet │ │ ├── lognormal_lpdf(y,mu,sigma).yasnippet │ │ ├── lognormal_rng(mu,sigma).yasnippet │ │ ├── map_rect(f,phi,theta,x_r,x_i).yasnippet │ │ ├── matrix_exp(A).yasnippet │ │ ├── matrix_exp_multiply(A,B).yasnippet │ │ ├── matrix_power(A,B).yasnippet │ │ ├── max(x).yasnippet │ │ ├── max(x,y).yasnippet │ │ ├── mdivide_left_spd(A,B).yasnippet │ │ ├── mdivide_left_spd(A,b).yasnippet │ │ ├── mdivide_left_tri_low(A,B).yasnippet │ │ ├── mdivide_left_tri_low(A,b).yasnippet │ │ ├── mdivide_right_spd(B,A).yasnippet │ │ ├── mdivide_right_spd(b,A).yasnippet │ │ ├── mdivide_right_tri_low(B,A).yasnippet │ │ ├── mdivide_right_tri_low(b,A).yasnippet │ │ ├── mean(x).yasnippet │ │ ├── min(x).yasnippet │ │ ├── min(x,y).yasnippet │ │ ├── modified_bessel_first_kind(v,z).yasnippet │ │ ├── modified_bessel_second_kind(v,z).yasnippet │ │ ├── multi_gp(Sigma,w).yasnippet │ │ ├── multi_gp_cholesky(L,w).yasnippet │ │ ├── multi_gp_cholesky_lpdf(y,L,w).yasnippet │ │ ├── multi_gp_lpdf(y,Sigma,w).yasnippet │ │ ├── multi_normal(mu,Sigma).yasnippet │ │ ├── multi_normal_cholesky(mu,L).yasnippet │ │ ├── multi_normal_cholesky_lpdf(y,mu,L).yasnippet │ │ ├── multi_normal_cholesky_rng(mu,L).yasnippet │ │ ├── multi_normal_lpdf(y,mu,Sigma).yasnippet │ │ ├── multi_normal_prec(mu,Omega).yasnippet │ │ ├── multi_normal_prec_lpdf(y,mu,Omega).yasnippet │ │ ├── multi_normal_rng(mu,Sigma).yasnippet │ │ ├── multi_student_t(nu,mu,Sigma).yasnippet │ │ ├── multi_student_t_lpdf(y,nu,mu,Sigma).yasnippet │ │ ├── multi_student_t_rng(nu,mu,Sigma).yasnippet │ │ ├── multinomial(theta).yasnippet │ │ ├── multinomial_logit(theta).yasnippet │ │ ├── multinomial_logit_lpmf(y,theta).yasnippet │ │ ├── multinomial_logit_rng(theta,N).yasnippet │ │ ├── multinomial_lpmf(y,theta).yasnippet │ │ ├── multinomial_rng(theta,N).yasnippet │ │ ├── multiply_log(x,y).yasnippet │ │ ├── multiply_lower_tri_self_transpose(x).yasnippet │ │ ├── neg_binomial(alpha,beta).yasnippet │ │ ├── neg_binomial_2(mu,phi).yasnippet │ │ ├── neg_binomial_2_cdf(n,mu,phi).yasnippet │ │ ├── neg_binomial_2_lccdf(n,mu,phi).yasnippet │ │ ├── neg_binomial_2_lcdf(n,mu,phi).yasnippet │ │ ├── neg_binomial_2_log(eta,phi).yasnippet │ │ ├── neg_binomial_2_log_glm(x,alpha,beta,phi).yasnippet │ │ ├── neg_binomial_2_log_glm_lpmf(y,x,alpha,beta,phi).yasnippet │ │ ├── neg_binomial_2_log_lpmf(n,eta,phi).yasnippet │ │ ├── neg_binomial_2_log_rng(eta,phi).yasnippet │ │ ├── neg_binomial_2_lpmf(n,mu,phi).yasnippet │ │ ├── neg_binomial_2_rng(mu,phi).yasnippet │ │ ├── neg_binomial_cdf(n,alpha,beta).yasnippet │ │ ├── neg_binomial_lccdf(n,alpha,beta).yasnippet │ │ ├── neg_binomial_lcdf(n,alpha,beta).yasnippet │ │ ├── neg_binomial_lpmf(n,alpha,beta).yasnippet │ │ ├── neg_binomial_rng(alpha,beta).yasnippet │ │ ├── normal(mu,sigma).yasnippet │ │ ├── normal_cdf(y,mu,sigma).yasnippet │ │ ├── normal_id_glm(x,alpha,beta,sigma).yasnippet │ │ ├── normal_id_glm_lpdf(y,x,alpha,beta,sigma).yasnippet │ │ ├── normal_lccdf(y,mu,sigma).yasnippet │ │ ├── normal_lcdf(y,mu,sigma).yasnippet │ │ ├── normal_lpdf(y,mu,sigma).yasnippet │ │ ├── normal_rng(mu,sigma).yasnippet │ │ ├── num_elements(x).yasnippet │ │ ├── ordered_logistic(eta,c).yasnippet │ │ ├── ordered_logistic_glm(x,beta,c).yasnippet │ │ ├── ordered_logistic_glm_lpmf(y,x,beta,c).yasnippet │ │ ├── ordered_logistic_lpmf(k,eta,c).yasnippet │ │ ├── ordered_logistic_rng(eta,c).yasnippet │ │ ├── ordered_probit(eta,c).yasnippet │ │ ├── ordered_probit_lpmf(k,eta,c).yasnippet │ │ ├── ordered_probit_rng(eta,c).yasnippet │ │ ├── owens_t(h,a).yasnippet │ │ ├── pareto(y_min,alpha).yasnippet │ │ ├── pareto_cdf(y,y_min,alpha).yasnippet │ │ ├── pareto_lccdf(y,y_min,alpha).yasnippet │ │ ├── pareto_lcdf(y,y_min,alpha).yasnippet │ │ ├── pareto_lpdf(y,y_min,alpha).yasnippet │ │ ├── pareto_rng(y_min,alpha).yasnippet │ │ ├── pareto_type_2(mu,lambda,alpha).yasnippet │ │ ├── pareto_type_2_cdf(y,mu,lambda,alpha).yasnippet │ │ ├── pareto_type_2_lccdf(y,mu,lambda,alpha).yasnippet │ │ ├── pareto_type_2_lcdf(y,mu,lambda,alpha).yasnippet │ │ ├── pareto_type_2_lpdf(y,mu,lambda,alpha).yasnippet │ │ ├── pareto_type_2_rng(mu,lambda,alpha).yasnippet │ │ ├── poisson(lambda).yasnippet │ │ ├── poisson_cdf(n,lambda).yasnippet │ │ ├── poisson_lccdf(n,lambda).yasnippet │ │ ├── poisson_lcdf(n,lambda).yasnippet │ │ ├── poisson_log(alpha).yasnippet │ │ ├── poisson_log_glm(x,alpha,beta).yasnippet │ │ ├── poisson_log_glm_lpmf(y,x,alpha,beta).yasnippet │ │ ├── poisson_log_lpmf(n,alpha).yasnippet │ │ ├── poisson_log_rng(alpha).yasnippet │ │ ├── poisson_lpmf(n,lambda).yasnippet │ │ ├── poisson_rng(lambda).yasnippet │ │ ├── pow(x,y).yasnippet │ │ ├── print(x1,...,xN).yasnippet │ │ ├── prod(x).yasnippet │ │ ├── qr_Q(A).yasnippet │ │ ├── qr_R(A).yasnippet │ │ ├── qr_thin_Q(A).yasnippet │ │ ├── qr_thin_R(A).yasnippet │ │ ├── quad_form(A,B).yasnippet │ │ ├── quad_form_diag(m,rv).yasnippet │ │ ├── quad_form_diag(m,v).yasnippet │ │ ├── quad_form_sym(A,B).yasnippet │ │ ├── rank(v,s).yasnippet │ │ ├── rayleigh(sigma).yasnippet │ │ ├── rayleigh_cdf(y,sigma).yasnippet │ │ ├── rayleigh_lccdf(y,sigma).yasnippet │ │ ├── rayleigh_lcdf(y,sigma).yasnippet │ │ ├── rayleigh_lpdf(y,sigma).yasnippet │ │ ├── rayleigh_rng(sigma).yasnippet │ │ ├── reduce_sum(f,x,grainsize,s1,s2,...).yasnippet │ │ ├── reject(x1,...,xN).yasnippet │ │ ├── rep_array(x,k,m,n).yasnippet │ │ ├── rep_array(x,m,n).yasnippet │ │ ├── rep_array(x,n).yasnippet │ │ ├── rep_matrix(rv,m).yasnippet │ │ ├── rep_matrix(v,n).yasnippet │ │ ├── rep_matrix(x,m,n).yasnippet │ │ ├── rep_row_vector(x,n).yasnippet │ │ ├── rep_vector(x,m).yasnippet │ │ ├── reverse(v).yasnippet │ │ ├── rising_factorial(x,n).yasnippet │ │ ├── round(x).yasnippet │ │ ├── row(x,m).yasnippet │ │ ├── rows(x).yasnippet │ │ ├── rows_dot_product(x,y).yasnippet │ │ ├── rows_dot_self(x).yasnippet │ │ ├── scale_matrix_exp_multiply(t,A,B).yasnippet │ │ ├── scaled_inv_chi_square(nu,sigma).yasnippet │ │ ├── scaled_inv_chi_square_cdf(y,nu,sigma).yasnippet │ │ ├── scaled_inv_chi_square_lccdf(y,nu,sigma).yasnippet │ │ ├── scaled_inv_chi_square_lcdf(y,nu,sigma).yasnippet │ │ ├── scaled_inv_chi_square_lpdf(y,nu,sigma).yasnippet │ │ ├── scaled_inv_chi_square_rng(nu,sigma).yasnippet │ │ ├── sd(x).yasnippet │ │ ├── segment(rv,i,n).yasnippet │ │ ├── segment(sv,i,n).yasnippet │ │ ├── segment(v,i,n).yasnippet │ │ ├── sin(x).yasnippet │ │ ├── singular_values(A).yasnippet │ │ ├── sinh(x).yasnippet │ │ ├── size(x).yasnippet │ │ ├── skew_normal(xi,omega,alpha).yasnippet │ │ ├── skew_normal_cdf(y,xi,omega,alpha).yasnippet │ │ ├── skew_normal_lccdf(y,xi,omega,alpha).yasnippet │ │ ├── skew_normal_lcdf(y,xi,omega,alpha).yasnippet │ │ ├── skew_normal_lpdf(y,xi,omega,alpha).yasnippet │ │ ├── skew_normal_rng(xi,omega,alpha).yasnippet │ │ ├── softmax(x).yasnippet │ │ ├── sort_asc(v).yasnippet │ │ ├── sort_desc(v).yasnippet │ │ ├── sort_indices_asc(v).yasnippet │ │ ├── sort_indices_desc(v).yasnippet │ │ ├── sqrt(x).yasnippet │ │ ├── square(x).yasnippet │ │ ├── squared_distance(x,y).yasnippet │ │ ├── std_normal().yasnippet │ │ ├── std_normal_cdf(y).yasnippet │ │ ├── std_normal_lccdf(y).yasnippet │ │ ├── std_normal_lcdf(y).yasnippet │ │ ├── std_normal_lpdf(y).yasnippet │ │ ├── std_normal_rng().yasnippet │ │ ├── step(x).yasnippet │ │ ├── student_t(nu,mu,sigma).yasnippet │ │ ├── student_t_cdf(y,nu,mu,sigma).yasnippet │ │ ├── student_t_lccdf(y,nu,mu,sigma).yasnippet │ │ ├── student_t_lcdf(y,nu,mu,sigma).yasnippet │ │ ├── student_t_lpdf(y,nu,mu,sigma).yasnippet │ │ ├── student_t_rng(nu,mu,sigma).yasnippet │ │ ├── sub_col(x,i,j,n_rows).yasnippet │ │ ├── sub_row(x,i,j,n_cols).yasnippet │ │ ├── sum(x).yasnippet │ │ ├── tail(rv,n).yasnippet │ │ ├── tail(sv,n).yasnippet │ │ ├── tail(v,n).yasnippet │ │ ├── tan(x).yasnippet │ │ ├── tanh(x).yasnippet │ │ ├── tcrossprod(x).yasnippet │ │ ├── tgamma(x).yasnippet │ │ ├── to_array_1d(a).yasnippet │ │ ├── to_array_1d(m).yasnippet │ │ ├── to_array_1d(v).yasnippet │ │ ├── to_array_2d(m).yasnippet │ │ ├── to_matrix(a).yasnippet │ │ ├── to_matrix(a,m,n).yasnippet │ │ ├── to_matrix(a,m,n,col_major).yasnippet │ │ ├── to_matrix(m).yasnippet │ │ ├── to_matrix(m,m,n).yasnippet │ │ ├── to_matrix(m,m,n,col_major).yasnippet │ │ ├── to_matrix(v).yasnippet │ │ ├── to_matrix(v,m,n).yasnippet │ │ ├── to_matrix(v,m,n,col_major).yasnippet │ │ ├── to_row_vector(a).yasnippet │ │ ├── to_row_vector(m).yasnippet │ │ ├── to_row_vector(v).yasnippet │ │ ├── to_vector(a).yasnippet │ │ ├── to_vector(m).yasnippet │ │ ├── to_vector(v).yasnippet │ │ ├── trace(A).yasnippet │ │ ├── trace_gen_quad_form(D,A,B).yasnippet │ │ ├── trace_quad_form(A,B).yasnippet │ │ ├── trigamma(x).yasnippet │ │ ├── trunc(x).yasnippet │ │ ├── uniform(alpha,beta).yasnippet │ │ ├── uniform_cdf(y,alpha,beta).yasnippet │ │ ├── uniform_lccdf(y,alpha,beta).yasnippet │ │ ├── uniform_lcdf(y,alpha,beta).yasnippet │ │ ├── uniform_lpdf(y,alpha,beta).yasnippet │ │ ├── uniform_rng(alpha,beta).yasnippet │ │ ├── variance(x).yasnippet │ │ ├── von_mises(mu,kappa).yasnippet │ │ ├── von_mises_lpdf(y,mu,kappa).yasnippet │ │ ├── von_mises_rng(mu,kappa).yasnippet │ │ ├── weibull(alpha,sigma).yasnippet │ │ ├── weibull_cdf(y,alpha,sigma).yasnippet │ │ ├── weibull_lccdf(y,alpha,sigma).yasnippet │ │ ├── weibull_lcdf(y,alpha,sigma).yasnippet │ │ ├── weibull_lpdf(y,alpha,sigma).yasnippet │ │ ├── weibull_rng(alpha,sigma).yasnippet │ │ ├── wiener(alpha,tau,beta,delta).yasnippet │ │ ├── wiener_lpdf(y,alpha,tau,beta,delta).yasnippet │ │ ├── wishart(nu,Sigma).yasnippet │ │ ├── wishart_lpdf(W,nu,Sigma).yasnippet │ │ └── wishart_rng(nu,Sigma).yasnippet │ │ ├── generated_quantities.yasnippet │ │ ├── if.yasnippet │ │ ├── int.yasnippet │ │ ├── integrate_ode_bdf.yasnippet │ │ ├── integrate_ode_rk45.yasnippet │ │ ├── lower.yasnippet │ │ ├── lower_upper.yasnippet │ │ ├── matrix.yasnippet │ │ ├── model.yasnippet │ │ ├── ordered.yasnippet │ │ ├── parameters.yasnippet │ │ ├── positive_ordered.yasnippet │ │ ├── print.yasnippet │ │ ├── program.yasnippet │ │ ├── real.yasnippet │ │ ├── reject.yasnippet │ │ ├── row_vector.yasnippet │ │ ├── simplex.yasnippet │ │ ├── target.yasnippet │ │ ├── transformed_data.yasnippet │ │ ├── transformed_parameters.yasnippet │ │ ├── unit_vector.yasnippet │ │ ├── upper.yasnippet │ │ ├── vector.yasnippet │ │ └── while.yasnippet ├── stan-snippets.el └── test-stan-snippets.el └── update-versions.sh /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | github: stan-dev 2 | custom: https://mc-stan.org/support/ 3 | -------------------------------------------------------------------------------- /.github/workflows/test.yml: -------------------------------------------------------------------------------- 1 | name: make all 2 | 3 | on: 4 | pull_request: 5 | push: 6 | branches: 7 | - 'master' 8 | - '*' 9 | paths-ignore: 10 | 11 | jobs: 12 | build: 13 | name: Build and test 14 | runs-on: ubuntu-latest 15 | strategy: 16 | matrix: 17 | emacs_version: 18 | # Limit to one under each major version 19 | - 25.1 20 | # - 25.2 21 | # - 25.3 22 | # - 26.1 23 | # - 26.2 24 | - 26.3 25 | - 27.1 26 | - snapshot 27 | steps: 28 | # https://github.com/marketplace/actions/set-up-emacs 29 | - uses: purcell/setup-emacs@master 30 | with: 31 | version: ${{ matrix.emacs_version }} 32 | # https://github.com/marketplace/actions/setup-cask 33 | - uses: conao3/setup-cask@v1.1 34 | # https://github.com/actions/checkout 35 | - uses: actions/checkout@v2 36 | with: 37 | submodules: true 38 | - name: Run make test 39 | run: make test 40 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *~ 2 | .cask 3 | dist/ 4 | *.elc 5 | *.bak 6 | .DS_Store 7 | 8 | flycheck_* 9 | 10 | local-melpa/* 11 | rstanarm/* 12 | stan/* 13 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "stan-language-definitions"] 2 | path = stan-language-definitions 3 | url = https://github.com/jrnold/stan-language-definitions.git 4 | [submodule "local-melpa"] 5 | path = local-melpa 6 | url = https://github.com/kaz-yos/melpa.git 7 | [submodule "rstanarm"] 8 | path = rstanarm 9 | url = https://github.com/kaz-yos/rstanarm.git 10 | [submodule "stan"] 11 | path = stan 12 | url = https://github.com/kaz-yos/stan.git 13 | -------------------------------------------------------------------------------- /ac-stan/Cask: -------------------------------------------------------------------------------- 1 | (source gnu) 2 | (source melpa) 3 | 4 | (package-file "ac-stan.el") 5 | (files "ac-stan.el" "ac-dict") 6 | (depends-on "auto-complete") 7 | 8 | (development 9 | (depends-on "shut-up") ;; quiet emacs 10 | (depends-on "buttercup") 11 | (depends-on "package-lint") 12 | (depends-on "elisp-lint")) 13 | -------------------------------------------------------------------------------- /ac-stan/README.md: -------------------------------------------------------------------------------- 1 | # auto-complete support for Stan 2 | 3 | ![Example auto-completion](example_auto_completion.png) 4 | 5 | `ac-stan` adds a dictionary for the [`auto-complete`](https://github.com/auto-complete/auto-complete) mode covering [Stan](https://mc-stan.org) function names. Please note that the `auto-complete` mode has been archived and not under active development. 6 | 7 | 8 | ## Installation 9 | 10 | This is not on MELPA because `auto-complete` itself is semi-deprecated. Please clone this repo or otherwise copy the `ac-stan` folder to your local system. 11 | 12 | 13 | ## Configuration 14 | An example configuration using the [`use-package`](https://github.com/jwiegley/use-package) macro is the following. 15 | 16 | ```{lisp} 17 | (use-package ac-stan 18 | :load-path "path-to-your-directory/ac-stan/" 19 | ;; Add a hook to setup `ac-stan' upon `stan-mode' entry 20 | :hook (stan-mode . ac-stan-ac-mode-setup)) 21 | ``` 22 | 23 | It can also be written as follows. 24 | 25 | ```{lisp} 26 | (require 'ac-stan) 27 | ;; Add a hook to setup `ac-stan' upon `stan-mode' entry 28 | (add-hook 'stan-mode-hook 'ac-stan-ac-mode-setup) 29 | ``` 30 | 31 | ## Inner workings 32 | The `ac-dict/stan-mode` file is the dictionary file containing keywords in Stan. 33 | -------------------------------------------------------------------------------- /ac-stan/create_ac_dict.py: -------------------------------------------------------------------------------- 1 | import json 2 | import re 3 | import sys 4 | import os 5 | from os import path 6 | 7 | def gen_dictwords(data): 8 | words = set() 9 | for k in data['keywords']: 10 | for x in data['keywords'][k]: 11 | words.add(x) 12 | for k in data['types']: 13 | for x in data['types'][k]: 14 | words.add(x) 15 | for x in data['blocks']: 16 | words.add(x) 17 | for k, v in data['functions'].items(): 18 | if not v['operator']: 19 | words.add(k) 20 | if v['sampling']: 21 | words.add(v['sampling']) 22 | return '\n'.join(sorted(list(words))) 23 | 24 | if __name__ == '__main__': 25 | src, dst = sys.argv[1:3] 26 | with open(src, 'r') as f: 27 | data = json.load(f) 28 | dirname = path.dirname(dst) 29 | if not path.exists(dirname): 30 | os.makedirs(dirname) 31 | with open(dst, 'w') as f: 32 | f.write(gen_dictwords(data)) 33 | 34 | -------------------------------------------------------------------------------- /ac-stan/example_auto_completion.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stan-mode/150bbbe5fd3ad2b5a3dbfba9d291e66eeea1a581/ac-stan/example_auto_completion.png -------------------------------------------------------------------------------- /company-stan/Cask: -------------------------------------------------------------------------------- 1 | ;; -*- emacs-lisp -*- 2 | ;; https://cask.readthedocs.io/en/latest/guide/usage.html 3 | ;; To initialize for package development, run: 4 | ;; $ cask init --dev 5 | ;; To install dependencies, run: 6 | ;; $ cask install 7 | ;; Cask Domain Specific Language 8 | ;; https://cask.readthedocs.io/en/latest/guide/dsl.html 9 | 10 | ;; Add a package archive to install dependencies from. 11 | (source gnu) 12 | (source melpa) 13 | 14 | ;; Declare a package by taking the package metadata from 15 | ;; the given file. Relative filenames are relative to 16 | ;; the directory of the Cask file. 17 | (package-file "company-stan.el") 18 | 19 | ;; The files to include in the package built by cask package. 20 | ;; The patterns have the same format as the :files in an MELPA 21 | ;; recipe, as Cask uses the same library to build packages. 22 | (files "company-stan.el") 23 | 24 | ;; Specify a dependency of this package. 25 | ;; In the first variant, install the package from a package archive 26 | ;; (see source), optionally requiring a minimum-version. 27 | (depends-on "company") 28 | 29 | ;; Development dependencies are installed with cask install, 30 | ;; but are not included in package descriptors generated by 31 | ;; cask pkg-file and cask package. 32 | (development 33 | (depends-on "buttercup") 34 | (depends-on "package-lint") 35 | (depends-on "elisp-lint")) 36 | -------------------------------------------------------------------------------- /company-stan/example_completion.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stan-mode/150bbbe5fd3ad2b5a3dbfba9d291e66eeea1a581/company-stan/example_completion.png -------------------------------------------------------------------------------- /eldoc-stan/example_eldoc.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stan-mode/150bbbe5fd3ad2b5a3dbfba9d291e66eeea1a581/eldoc-stan/example_eldoc.png -------------------------------------------------------------------------------- /example.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stan-mode/150bbbe5fd3ad2b5a3dbfba9d291e66eeea1a581/example.gif -------------------------------------------------------------------------------- /example.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stan-mode/150bbbe5fd3ad2b5a3dbfba9d291e66eeea1a581/example.png -------------------------------------------------------------------------------- /example_schools_mod_ncp.stan: -------------------------------------------------------------------------------- 1 | // The Eight Schools example with non-centered parametrization. 2 | // https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta = mu + tau * eta; 16 | } 17 | model { 18 | mu ~ normal(0, 10); 19 | tau ~ cauchy(0, 10); 20 | eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/.gitignore: -------------------------------------------------------------------------------- 1 | examples/*.cpp 2 | examples/*.hpp 3 | -------------------------------------------------------------------------------- /flycheck-stan/Cask: -------------------------------------------------------------------------------- 1 | ;; -*- emacs-lisp -*- 2 | ;; https://cask.readthedocs.io/en/latest/guide/usage.html 3 | ;; To initialize for package development, run: 4 | ;; $ cask init --dev 5 | ;; To install dependencies, run: 6 | ;; $ cask install 7 | ;; Cask Domain Specific Language 8 | ;; https://cask.readthedocs.io/en/latest/guide/dsl.html 9 | 10 | ;; Add a package archive to install dependencies from. 11 | (source gnu) 12 | (source melpa) 13 | 14 | ;; Declare a package by taking the package metadata from 15 | ;; the given file. Relative filenames are relative to 16 | ;; the directory of the Cask file. 17 | (package-file "flycheck-stan.el") 18 | 19 | ;; The files to include in the package built by cask package. 20 | ;; The patterns have the same format as the :files in an MELPA 21 | ;; recipe, as Cask uses the same library to build packages. 22 | (files "flycheck-stan.el") 23 | 24 | ;; Specify a dependency of this package. 25 | ;; In the first variant, install the package from a package archive 26 | ;; (see source), optionally requiring a minimum-version. 27 | (depends-on "flycheck") 28 | 29 | ;; Development dependencies are installed with cask install, 30 | ;; but are not included in package descriptors generated by 31 | ;; cask pkg-file and cask package. 32 | (development 33 | (depends-on "buttercup") 34 | (depends-on "package-lint") 35 | (depends-on "elisp-lint")) 36 | -------------------------------------------------------------------------------- /flycheck-stan/example_flycheck.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stan-mode/150bbbe5fd3ad2b5a3dbfba9d291e66eeea1a581/flycheck-stan/example_flycheck.png -------------------------------------------------------------------------------- /flycheck-stan/examples/01_example_error_number_model_name.stan: -------------------------------------------------------------------------------- 1 | // The Eight Schools example with non-centered parametrization. 2 | // https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta = mu + tau * eta; 16 | } 17 | model { 18 | mu ~ normal(0, 10); 19 | tau ~ cauchy(0, 10); 20 | eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/01_example_error_number_model_name.stanc3out.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stan-mode/150bbbe5fd3ad2b5a3dbfba9d291e66eeea1a581/flycheck-stan/examples/01_example_error_number_model_name.stanc3out.txt -------------------------------------------------------------------------------- /flycheck-stan/examples/01_example_error_number_model_name.stancout.txt: -------------------------------------------------------------------------------- 1 | 2 | model_name must not start with a number or symbol other than _ 3 | Could not remove output file=examples/01_example_error_number_model_name.cpp 4 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_and_info_composite.stan: -------------------------------------------------------------------------------- 1 | # The Eight Schools example with non-centered parametrization. 2 | # https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | rear mu; 10 | // The parser stops at the above line. 11 | // Any issues below are not detected. 12 | real tau; 13 | // This undefined K is not detected. 14 | vector[K] eta; 15 | } 16 | transformed parameters { 17 | vector[J] theta; 18 | theta <- mu + tau * eta; 19 | } 20 | model { 21 | increment_log_prob(normal_log(mu, 0, 10)); 22 | target += cauchy_log(tau, 0, 10); 23 | eta ~ normal(0, 1); # implies theta ~ normal(mu, tau) 24 | y ~ normal(theta, sigma); 25 | } 26 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_and_info_composite.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_error_and_info_composite_model 2 | Input file=examples/example_error_and_info_composite.stan 3 | Output file=examples/example_error_and_info_composite.cpp 4 | 5 | SYNTAX ERROR, MESSAGE(S) FROM PARSER: 6 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 7 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 8 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 9 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 10 | error in 'examples/example_error_and_info_composite.stan' at line 9, column 2 11 | ------------------------------------------------- 12 | 7: } 13 | 8: parameters { 14 | 9: rear mu; 15 | ^ 16 | 10: // The parser stops at the above line. 17 | ------------------------------------------------- 18 | 19 | PARSER EXPECTED: 26 | 27 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_and_info_misspelled_type.stan: -------------------------------------------------------------------------------- 1 | # The Eight Schools example with non-centered parametrization. 2 | # https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | rear mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta <- mu + tau * eta; 16 | } 17 | model { 18 | increment_log_prob(normal_log(mu, 0, 10)); 19 | target += cauchy_log(tau, 0, 10); 20 | eta ~ normal(0, 1); # implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_and_info_misspelled_type.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_error_and_info_misspelled_type_model 2 | Input file=examples/example_error_and_info_misspelled_type.stan 3 | Output file=examples/example_error_and_info_misspelled_type.cpp 4 | 5 | SYNTAX ERROR, MESSAGE(S) FROM PARSER: 6 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 7 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 8 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 9 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 10 | error in 'examples/example_error_and_info_misspelled_type.stan' at line 9, column 2 11 | ------------------------------------------------- 12 | 7: } 13 | 8: parameters { 14 | 9: rear mu; 15 | ^ 16 | 10: real tau; 17 | ------------------------------------------------- 18 | 19 | PARSER EXPECTED: 26 | 27 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_and_info_not_conditional.stan: -------------------------------------------------------------------------------- 1 | # The Eight Schools example with non-centered parametrization. 2 | # https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta = mu + tau * eta; 16 | } 17 | model { 18 | mu ~ normal(0, 10); 19 | target += cauchy_lpdf(tau, 0, 10); 20 | eta ~ normal(0, 1); # implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_and_info_not_conditional.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_error_and_info_not_conditional_model 2 | Input file=examples/example_error_and_info_not_conditional.stan 3 | Output file=examples/example_error_and_info_not_conditional.cpp 4 | 5 | SYNTAX ERROR, MESSAGE(S) FROM PARSER: 6 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 7 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 8 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 9 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 10 | Probabilty functions with suffixes _lpdf, _lpmf, _lcdf, and _lccdf, 11 | require a vertical bar (|) between the first two arguments. 12 | error in 'examples/example_error_and_info_not_conditional.stan' at line 19, column 27 13 | ------------------------------------------------- 14 | 17: model { 15 | 18: mu ~ normal(0, 10); 16 | 19: target += cauchy_lpdf(tau, 0, 10); 17 | ^ 18 | 20: eta ~ normal(0, 1); # implies theta ~ normal(mu, tau) 19 | ------------------------------------------------- 20 | 21 | PARSER EXPECTED: "|" 22 | 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_and_info_undefined_function.stan: -------------------------------------------------------------------------------- 1 | # The Eight Schools example with non-centered parametrization. 2 | # https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta = mu + tau * eta; 16 | } 17 | model { 18 | mu ~ normall(0, 10); 19 | tau ~ cauchy(0, 10); 20 | eta ~ normal(0, 1); # implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_and_info_undefined_function.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_error_and_info_undefined_function_model 2 | Input file=examples/example_error_and_info_undefined_function.stan 3 | Output file=examples/example_error_and_info_undefined_function.cpp 4 | 5 | SYNTAX ERROR, MESSAGE(S) FROM PARSER: 6 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 7 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 8 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 9 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 10 | Probability function must end in _lpdf or _lpmf. Found distribution family = normall with no corresponding probability function normall_lpdf, normall_lpmf, or normall_log 11 | error in 'examples/example_error_and_info_undefined_function.stan' at line 18, column 22 12 | ------------------------------------------------- 13 | 16: } 14 | 17: model { 15 | 18: mu ~ normall(0, 10); 16 | ^ 17 | 19: tau ~ cauchy(0, 10); 18 | ------------------------------------------------- 19 | 20 | 21 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_and_info_undefined_include_file.stan: -------------------------------------------------------------------------------- 1 | # The Eight Schools example with non-centered parametrization. 2 | # https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | functions { 4 | #include no_such_file.stan 5 | } 6 | data { 7 | int J; 8 | vector[J] y; 9 | vector[J] sigma; 10 | } 11 | parameters { 12 | real mu; 13 | real tau; 14 | vector[J] eta; 15 | } 16 | transformed parameters { 17 | vector[J] theta; 18 | theta = mu + tau * eta; 19 | } 20 | model { 21 | mu ~ normal(0, 10); 22 | tau ~ cauchy(0, 10); 23 | eta ~ normal(0, 1); # implies theta ~ normal(mu, tau) 24 | y ~ normal(theta, sigma); 25 | } 26 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_and_info_undefined_include_file.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_error_and_info_undefined_include_file_model 2 | Input file=examples/example_error_and_info_undefined_include_file.stan 3 | Output file=examples/example_error_and_info_undefined_include_file.cpp 4 | 5 | could not find include file no_such_file.stan in the following directories: 6 | 7 | 8 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_and_info_undefined_variable.stan: -------------------------------------------------------------------------------- 1 | # The Eight Schools example with non-centered parametrization. 2 | # https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | # real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta = mu + tau * eta; 16 | } 17 | model { 18 | mu ~ normal(0, 10); 19 | tau ~ cauchy(0, 10); 20 | eta ~ normal(0, 1); # implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_and_info_undefined_variable.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_error_and_info_undefined_variable_model 2 | Input file=examples/example_error_and_info_undefined_variable.stan 3 | Output file=examples/example_error_and_info_undefined_variable.cpp 4 | 5 | SYNTAX ERROR, MESSAGE(S) FROM PARSER: 6 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 7 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 8 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 9 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 10 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 11 | Variable "mu" does not exist. 12 | error in 'examples/example_error_and_info_undefined_variable.stan' at line 15, column 12 13 | ------------------------------------------------- 14 | 13: transformed parameters { 15 | 14: vector[J] theta; 16 | 15: theta = mu + tau * eta; 17 | ^ 18 | 16: } 19 | ------------------------------------------------- 20 | 21 | 22 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_invalid_character.stan: -------------------------------------------------------------------------------- 1 | // The Eight Schools example with non-centered parametrization. 2 | // https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta;$ 15 | theta = mu + tau * eta; 16 | } 17 | model { 18 | mu ~ normal(0, 10); 19 | tau ~ cauchy(0, 10); 20 | eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_invalid_character.stanc3out.txt: -------------------------------------------------------------------------------- 1 | 2 | Syntax error in 'examples/example_error_invalid_character.stan', line 14, column 17, lexing error: 3 | ------------------------------------------------- 4 | 12: } 5 | 13: transformed parameters { 6 | 14: vector[J] theta;$ 7 | ^ 8 | 15: theta = mu + tau * eta; 9 | 16: } 10 | ------------------------------------------------- 11 | 12 | Invalid character found. 13 | 14 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_invalid_character.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_error_invalid_character_model 2 | Input file=examples/example_error_invalid_character.stan 3 | Output file=examples/example_error_invalid_character.cpp 4 | 5 | SYNTAX ERROR, MESSAGE(S) FROM PARSER: 6 | error in 'examples/example_error_invalid_character.stan' at line 14, column 18 7 | ------------------------------------------------- 8 | 12: } 9 | 13: transformed parameters { 10 | 14: vector[J] theta;$ 11 | ^ 12 | 15: theta = mu + tau * eta; 13 | ------------------------------------------------- 14 | 15 | PARSER EXPECTED: 22 | or '}' to close variable declarations and definitions> 23 | 24 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_misspelled_type.stan: -------------------------------------------------------------------------------- 1 | // The Eight Schools example with non-centered parametrization. 2 | // https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | rear mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta = mu + tau * eta; 16 | } 17 | model { 18 | mu ~ normal(0, 10); 19 | tau ~ cauchy(0, 10); 20 | eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_misspelled_type.stanc3out.txt: -------------------------------------------------------------------------------- 1 | 2 | Syntax error in 'examples/example_error_misspelled_type.stan', line 8, column 11 to column 12, parsing error: 3 | ------------------------------------------------- 4 | 6: vector[J] sigma; 5 | 7: } 6 | 8: parameters { 7 | ^ 8 | 9: rear mu; 9 | 10: real tau; 10 | ------------------------------------------------- 11 | 12 | Expected top-level variable declaration or "}". 13 | 14 | 15 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_misspelled_type.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_error_misspelled_type_model 2 | Input file=examples/example_error_misspelled_type.stan 3 | Output file=examples/example_error_misspelled_type.cpp 4 | 5 | SYNTAX ERROR, MESSAGE(S) FROM PARSER: 6 | error in 'examples/example_error_misspelled_type.stan' at line 9, column 2 7 | ------------------------------------------------- 8 | 7: } 9 | 8: parameters { 10 | 9: rear mu; 11 | ^ 12 | 10: real tau; 13 | ------------------------------------------------- 14 | 15 | PARSER EXPECTED: 22 | 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_not_conditional.stan: -------------------------------------------------------------------------------- 1 | // The Eight Schools example with non-centered parametrization. 2 | // https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta = mu + tau * eta; 16 | } 17 | model { 18 | mu ~ normal(0, 10); 19 | target += cauchy_lpdf(tau, 0, 10); 20 | eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_not_conditional.stanc3out.txt: -------------------------------------------------------------------------------- 1 | 2 | Semantic error in 'examples/example_error_not_conditional.stan', line 19, column 12 to column 35: 3 | ------------------------------------------------- 4 | 17: model { 5 | 18: mu ~ normal(0, 10); 6 | 19: target += cauchy_lpdf(tau, 0, 10); 7 | ^ 8 | 20: eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 9 | 21: y ~ normal(theta, sigma); 10 | ------------------------------------------------- 11 | 12 | Probabilty functions with suffixes _lpdf, _lpmf, _lcdf, and _lccdf, require a vertical bar (|) between the first two arguments. 13 | 14 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_not_conditional.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_error_not_conditional_model 2 | Input file=examples/example_error_not_conditional.stan 3 | Output file=examples/example_error_not_conditional.cpp 4 | 5 | SYNTAX ERROR, MESSAGE(S) FROM PARSER: 6 | Probabilty functions with suffixes _lpdf, _lpmf, _lcdf, and _lccdf, 7 | require a vertical bar (|) between the first two arguments. 8 | error in 'examples/example_error_not_conditional.stan' at line 19, column 27 9 | ------------------------------------------------- 10 | 17: model { 11 | 18: mu ~ normal(0, 10); 12 | 19: target += cauchy_lpdf(tau, 0, 10); 13 | ^ 14 | 20: eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 15 | ------------------------------------------------- 16 | 17 | PARSER EXPECTED: "|" 18 | 19 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_undefined_function.stan: -------------------------------------------------------------------------------- 1 | // The Eight Schools example with non-centered parametrization. 2 | // https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta = mu + tau * eta; 16 | } 17 | model { 18 | mu ~ normall(0, 10); 19 | tau ~ cauchy(0, 10); 20 | eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_undefined_function.stanc3out.txt: -------------------------------------------------------------------------------- 1 | 2 | Semantic error in 'examples/example_error_undefined_function.stan', line 18, column 2 to column 22: 3 | ------------------------------------------------- 4 | 16: } 5 | 17: model { 6 | 18: mu ~ normall(0, 10); 7 | ^ 8 | 19: tau ~ cauchy(0, 10); 9 | 20: eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 10 | ------------------------------------------------- 11 | 12 | Ill-typed arguments to '~' statement. No distribution 'normall' was found with the correct signature. 13 | 14 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_undefined_function.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_error_undefined_function_model 2 | Input file=examples/example_error_undefined_function.stan 3 | Output file=examples/example_error_undefined_function.cpp 4 | 5 | SYNTAX ERROR, MESSAGE(S) FROM PARSER: 6 | Probability function must end in _lpdf or _lpmf. Found distribution family = normall with no corresponding probability function normall_lpdf, normall_lpmf, or normall_log 7 | error in 'examples/example_error_undefined_function.stan' at line 18, column 22 8 | ------------------------------------------------- 9 | 16: } 10 | 17: model { 11 | 18: mu ~ normall(0, 10); 12 | ^ 13 | 19: tau ~ cauchy(0, 10); 14 | ------------------------------------------------- 15 | 16 | 17 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_undefined_include_file.stan: -------------------------------------------------------------------------------- 1 | // The Eight Schools example with non-centered parametrization. 2 | // https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | functions { 4 | #include no_such_file.stan 5 | } 6 | data { 7 | int J; 8 | vector[J] y; 9 | vector[J] sigma; 10 | } 11 | parameters { 12 | real mu; 13 | real tau; 14 | vector[J] eta; 15 | } 16 | transformed parameters { 17 | vector[J] theta; 18 | theta = mu + tau * eta; 19 | } 20 | model { 21 | mu ~ normal(0, 10); 22 | tau ~ cauchy(0, 10); 23 | eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 24 | y ~ normal(theta, sigma); 25 | } 26 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_undefined_include_file.stanc3out.txt: -------------------------------------------------------------------------------- 1 | 2 | Syntax error in 'examples/example_error_undefined_include_file.stan', line 4, column 0, include error: 3 | ------------------------------------------------- 4 | 2: // https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 5 | 3: functions { 6 | 4: #include no_such_file.stan 7 | ^ 8 | 5: } 9 | 6: data { 10 | ------------------------------------------------- 11 | 12 | Could not find include file no_such_file.stan in specified include paths. 13 | 14 | 15 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_undefined_include_file.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_error_undefined_include_file_model 2 | Input file=examples/example_error_undefined_include_file.stan 3 | Output file=examples/example_error_undefined_include_file.cpp 4 | 5 | could not find include file no_such_file.stan in the following directories: 6 | 7 | 8 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_undefined_variable.stan: -------------------------------------------------------------------------------- 1 | // The Eight Schools example with non-centered parametrization. 2 | // https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | // real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta = mu + tau * eta; 16 | } 17 | model { 18 | mu ~ normal(0, 10); 19 | tau ~ cauchy(0, 10); 20 | eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_undefined_variable.stanc3out.txt: -------------------------------------------------------------------------------- 1 | 2 | Semantic error in 'examples/example_error_undefined_variable.stan', line 15, column 10 to column 12: 3 | ------------------------------------------------- 4 | 13: transformed parameters { 5 | 14: vector[J] theta; 6 | 15: theta = mu + tau * eta; 7 | ^ 8 | 16: } 9 | 17: model { 10 | ------------------------------------------------- 11 | 12 | Identifier 'mu' not in scope. 13 | 14 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_error_undefined_variable.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_error_undefined_variable_model 2 | Input file=examples/example_error_undefined_variable.stan 3 | Output file=examples/example_error_undefined_variable.cpp 4 | 5 | SYNTAX ERROR, MESSAGE(S) FROM PARSER: 6 | Variable "mu" does not exist. 7 | error in 'examples/example_error_undefined_variable.stan' at line 15, column 12 8 | ------------------------------------------------- 9 | 13: transformed parameters { 10 | 14: vector[J] theta; 11 | 15: theta = mu + tau * eta; 12 | ^ 13 | 16: } 14 | ------------------------------------------------- 15 | 16 | 17 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_failure_and_info_misspelled_block.stan: -------------------------------------------------------------------------------- 1 | # The Eight Schools example with non-centered parametrization. 2 | # https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | pparameters { 9 | real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta = mu + tau * eta; 16 | } 17 | model { 18 | mu ~ normal(0, 10); 19 | tau ~ cauchy(0, 10); 20 | eta ~ normal(0, 1); # implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_failure_misspelled_block.stan: -------------------------------------------------------------------------------- 1 | // The Eight Schools example with non-centered parametrization. 2 | // https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | pparameters { 9 | real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta = mu + tau * eta; 16 | } 17 | model { 18 | mu ~ normal(0, 10); 19 | tau ~ cauchy(0, 10); 20 | eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_failure_misspelled_block.stanc3out.txt: -------------------------------------------------------------------------------- 1 | 2 | Syntax error in 'examples/example_failure_misspelled_block.stan', line 3, column 0 to line 7, column 1, parsing error: 3 | ------------------------------------------------- 4 | 5: vector[J] y; 5 | 6: vector[J] sigma; 6 | 7: } 7 | ^ 8 | 8: pparameters { 9 | 9: real mu; 10 | ------------------------------------------------- 11 | 12 | Expected "transformed data {" or "parameters {" or "transformed parameters {" or "model {" or "generated quantities {". 13 | 14 | 15 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_failure_misspelled_block.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_failure_misspelled_block_model 2 | Input file=examples/example_failure_misspelled_block.stan 3 | Output file=examples/example_failure_misspelled_block.cpp 4 | 5 | PARSER FAILED TO PARSE INPUT COMPLETELY 6 | STOPPED AT LINE 8: 7 | pparameters { 8 | real mu; 9 | real tau; 10 | vector[J] eta; 11 | } 12 | transformed parameters { 13 | vector[J] theta; 14 | theta = mu + tau * eta; 15 | } 16 | model { 17 | mu ~ normal(0, 10); 18 | tau ~ cauchy(0, 10); 19 | eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 20 | y ~ normal(theta, sigma); 21 | } 22 | 23 | 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_info_composite.stan: -------------------------------------------------------------------------------- 1 | # The Eight Schools example with non-centered parametrization. 2 | # https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta <- mu + tau * eta; 16 | } 17 | model { 18 | exp(log(mu)) ~ normal(0, 10); 19 | increment_log_prob(cauchy_log(tau, 0, 10)); 20 | eta ~ normal(0, 1); # implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_info_composite.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_info_composite_model 2 | Input file=examples/example_info_composite.stan 3 | Output file=examples/example_info_composite.cpp 4 | DIAGNOSTIC(S) FROM PARSER: 5 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 6 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 7 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 8 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 9 | Info: assignment operator <- deprecated in the Stan language; use = instead. 10 | Info: 11 | Left-hand side of sampling statement (~) may contain a non-linear transform of a parameter or local variable. 12 | If it does, you need to include a target += statement with the log absolute determinant of the Jacobian of the transform. 13 | Left-hand-side of sampling statement: 14 | stan::math::exp(stan::math::log(mu)) ~ normal(...) 15 | Info: increment_log_prob(...); is deprecated and will be removed in the future. 16 | Use target += ...; instead. 17 | Info: Deprecated function 'cauchy_log'; please replace suffix '_log' with '_lpdf' for density functions or '_lpmf' for mass functions 18 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 19 | 20 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_info_composite_with_error.stan: -------------------------------------------------------------------------------- 1 | # The Eight Schools example with non-centered parametrization. 2 | # https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta <- mu + tau * eta; 16 | } 17 | model { 18 | exp(log(mu)) ~ normal(0, 10); 19 | increment_log_prob(cauchy_log(tau, 0, 10)); 20 | eta ~ normal(0, 1); # implies theta ~ normal(mu, tau) 21 | increment_log_prob(normal_lpdf(y, theta, sigma)); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_info_deprecated_assignment.stan: -------------------------------------------------------------------------------- 1 | // The Eight Schools example with non-centered parametrization. 2 | // https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta <- mu + tau * eta; 16 | } 17 | model { 18 | mu ~ normal(0, 10); 19 | tau ~ cauchy(0, 10); 20 | eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_info_deprecated_assignment.stanc3out.txt: -------------------------------------------------------------------------------- 1 | 2 | Warning: deprecated language construct used in 'examples/example_info_deprecated_assignment.stan', line 15, column 9: 3 | ------------------------------------------------- 4 | 13: transformed parameters { 5 | 14: vector[J] theta; 6 | 15: theta <- mu + tau * eta; 7 | ^ 8 | 16: } 9 | 17: model { 10 | ------------------------------------------------- 11 | 12 | assignment operator <- is deprecated in the Stan language; use = instead. 13 | 14 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_info_deprecated_assignment.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_info_deprecated_assignment_model 2 | Input file=examples/example_info_deprecated_assignment.stan 3 | Output file=examples/example_info_deprecated_assignment.cpp 4 | DIAGNOSTIC(S) FROM PARSER: 5 | Info: assignment operator <- deprecated in the Stan language; use = instead. 6 | 7 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_info_deprecated_comments.stan: -------------------------------------------------------------------------------- 1 | # The Eight Schools example with non-centered parametrization. 2 | # https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta = mu + tau * eta; 16 | } 17 | model { 18 | mu ~ normal(0, 10); 19 | tau ~ cauchy(0, 10); 20 | eta ~ normal(0, 1); # implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_info_deprecated_comments.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_info_deprecated_comments_model 2 | Input file=examples/example_info_deprecated_comments.stan 3 | Output file=examples/example_info_deprecated_comments.cpp 4 | DIAGNOSTIC(S) FROM PARSER: 5 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 6 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 7 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 8 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 9 | Info: Comments beginning with # are deprecated. Please use // in place of # for line comments. 10 | 11 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_info_deprecated_functions.stan: -------------------------------------------------------------------------------- 1 | // The Eight Schools example with non-centered parametrization. 2 | // https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta = mu + tau * eta; 16 | } 17 | model { 18 | increment_log_prob(normal_log(mu, 0, 10)); 19 | target += cauchy_log(tau, 0, 10); 20 | eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_info_deprecated_functions.stanc3out.txt: -------------------------------------------------------------------------------- 1 | 2 | Warning: deprecated language construct used in 'examples/example_info_deprecated_functions.stan', line 18, column 19: 3 | ------------------------------------------------- 4 | 16: } 5 | 17: model { 6 | 18: increment_log_prob(normal_log(mu, 0, 10)); 7 | ^ 8 | 19: target += cauchy_log(tau, 0, 10); 9 | 20: eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 10 | ------------------------------------------------- 11 | 12 | increment_log_prob(...); is deprecated and will be removed in the future. Use target += ...; instead. 13 | 14 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_info_deprecated_functions.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_info_deprecated_functions_model 2 | Input file=examples/example_info_deprecated_functions.stan 3 | Output file=examples/example_info_deprecated_functions.cpp 4 | DIAGNOSTIC(S) FROM PARSER: 5 | Info: increment_log_prob(...); is deprecated and will be removed in the future. 6 | Use target += ...; instead. 7 | Info: Deprecated function 'normal_log'; please replace suffix '_log' with '_lpdf' for density functions or '_lpmf' for mass functions 8 | Info: Deprecated function 'cauchy_log'; please replace suffix '_log' with '_lpdf' for density functions or '_lpmf' for mass functions 9 | 10 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_info_jacobian.stan: -------------------------------------------------------------------------------- 1 | // The Eight Schools example with non-centered parametrization. 2 | // https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta = mu + tau * eta; 16 | } 17 | model { 18 | exp(log(mu)) ~ normal(0, 10); 19 | tau ~ cauchy(0, 10); 20 | eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_info_jacobian.stanc3out.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stan-mode/150bbbe5fd3ad2b5a3dbfba9d291e66eeea1a581/flycheck-stan/examples/example_info_jacobian.stanc3out.txt -------------------------------------------------------------------------------- /flycheck-stan/examples/example_info_jacobian.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_info_jacobian_model 2 | Input file=examples/example_info_jacobian.stan 3 | Output file=examples/example_info_jacobian.cpp 4 | DIAGNOSTIC(S) FROM PARSER: 5 | Info: 6 | Left-hand side of sampling statement (~) may contain a non-linear transform of a parameter or local variable. 7 | If it does, you need to include a target += statement with the log absolute determinant of the Jacobian of the transform. 8 | Left-hand-side of sampling statement: 9 | stan::math::exp(stan::math::log(mu)) ~ normal(...) 10 | 11 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_ok.stan: -------------------------------------------------------------------------------- 1 | // The Eight Schools example with non-centered parametrization. 2 | // https://mc-stan.org/bayesplot/articles/visual-mcmc-diagnostics.html 3 | data { 4 | int J; 5 | vector[J] y; 6 | vector[J] sigma; 7 | } 8 | parameters { 9 | real mu; 10 | real tau; 11 | vector[J] eta; 12 | } 13 | transformed parameters { 14 | vector[J] theta; 15 | theta = mu + tau * eta; 16 | } 17 | model { 18 | mu ~ normal(0, 10); 19 | tau ~ cauchy(0, 10); 20 | eta ~ normal(0, 1); // implies theta ~ normal(mu, tau) 21 | y ~ normal(theta, sigma); 22 | } 23 | -------------------------------------------------------------------------------- /flycheck-stan/examples/example_ok.stanc3out.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stan-mode/150bbbe5fd3ad2b5a3dbfba9d291e66eeea1a581/flycheck-stan/examples/example_ok.stanc3out.txt -------------------------------------------------------------------------------- /flycheck-stan/examples/example_ok.stancout.txt: -------------------------------------------------------------------------------- 1 | Model name=example_ok_model 2 | Input file=examples/example_ok.stan 3 | Output file=examples/example_ok.cpp 4 | -------------------------------------------------------------------------------- /indent-stan-files/Cask: -------------------------------------------------------------------------------- 1 | (source gnu) 2 | (source melpa) 3 | (depends-on "stan-mode") 4 | (depends-on "shut-up") 5 | 6 | -------------------------------------------------------------------------------- /indent-stan-files/Makefile: -------------------------------------------------------------------------------- 1 | PYTHON ?= python3 2 | SED ?= sed 3 | CASK ?= cask 4 | EMACS ?= emacs 5 | export EMACS 6 | EMACSFLAGS ?= 7 | PKGDIR := $(shell EMACS=$(EMACS) $(CASK) package-directory) 8 | EMACSBATCH = $(EMACS) -Q --batch $(EMACSFLAGS) 9 | 10 | build : $(PKGDIR) 11 | 12 | clean : 13 | rm -rf .cask/ 14 | 15 | $(PKGDIR) : Cask 16 | $(CASK) install 17 | touch $(PKGDIR) 18 | 19 | -------------------------------------------------------------------------------- /indent-stan-files/README.md: -------------------------------------------------------------------------------- 1 | # Indent Stan Files 2 | 3 | The Bash script `indent-stan-file` uses Emacs `stan-mode` to indent a Stan model file. 4 | 5 | ## Install 6 | 7 | 1. Download this directory however you so desire. 8 | 2. If not already installed, install Cask using the instructions [here](http://cask.readthedocs.org/en/latest/). 9 | 3. In the `indent-stan-files` directory, run `make build` to install Emacs dependencies. 10 | 11 | ## Usage 12 | 13 | The script `indent-stan-files` only indents one model file at a time. 14 | To indent a file in place: 15 | ```console 16 | indent-stan-files intputfile.stan 17 | ``` 18 | To indent a file and save it to another file: 19 | ```console 20 | indent-stan-files intputfile.stan outputfile.stan 21 | ``` 22 | -------------------------------------------------------------------------------- /stan-mode/Cask: -------------------------------------------------------------------------------- 1 | (source gnu) 2 | (source melpa) 3 | 4 | (package-file "stan-mode.el") 5 | (depends-on "yasnippet") 6 | 7 | (development 8 | (depends-on "shut-up") ;; quiet emacs 9 | (depends-on "buttercup") 10 | (depends-on "package-lint") 11 | (depends-on "elisp-lint")) 12 | -------------------------------------------------------------------------------- /stan-snippets/Cask: -------------------------------------------------------------------------------- 1 | (source gnu) 2 | (source melpa) 3 | 4 | (package-file "stan-snippets.el") 5 | 6 | (files "stan-snippets.el" "snippets") 7 | 8 | (development 9 | (depends-on "shut-up") ;; quiet emacs 10 | (depends-on "buttercup") 11 | (depends-on "package-lint") 12 | (depends-on "elisp-lint")) 13 | -------------------------------------------------------------------------------- /stan-snippets/example_snippet.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stan-mode/150bbbe5fd3ad2b5a3dbfba9d291e66eeea1a581/stan-snippets/example_snippet.png -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/.yas-make-groups: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stan-mode/150bbbe5fd3ad2b5a3dbfba9d291e66eeea1a581/stan-snippets/snippets/stan-mode/.yas-make-groups -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/.yas-parents: -------------------------------------------------------------------------------- 1 | text-mode 2 | -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/cholesky_factor_corr.yasnippet: -------------------------------------------------------------------------------- 1 | # name: cholesky_factor_corr[] ... ; 2 | # key: cholesky_factor_corr 3 | # group: Types 4 | # -- 5 | cholesky_factor_corr[${1:expression}${2:${3:, ${4:expression}}}] ${5:variable}${6:[${7:dims}]}; 6 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/cholesky_factor_cov.yasnippet: -------------------------------------------------------------------------------- 1 | # name: cholesky_factor_cov[] ... ; 2 | # key: cholesky_factor_cov 3 | # group: Types 4 | # -- 5 | cholesky_factor_cov[${1:expression}${2:${3:, ${4:expression}}}] ${5:variable}${6:[${7:dims}]}; 6 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/corr_matrix.yasnippet: -------------------------------------------------------------------------------- 1 | # name: corr_matrix[] ... ; 2 | # key: corr_matrix 3 | # group: Types 4 | # -- 5 | corr_matrix[${1:expression}] ${2:variable}${3:[${4:dims}]}; 6 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/cov_matrix.yasnippet: -------------------------------------------------------------------------------- 1 | # name: cov_matrix[] ... ; 2 | # key: cov_matrix 3 | # group: Types 4 | # -- 5 | cov_matrix[${1:expression}] ${2:variable}${3:[${4:dims}]}; 6 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/data.yasnippet: -------------------------------------------------------------------------------- 1 | # name: data {...} 2 | # key: data 3 | # group: Blocks 4 | # -- 5 | data { 6 | $0 7 | } 8 | -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/elif.yasnippet: -------------------------------------------------------------------------------- 1 | # name: else if (...) { ... } 2 | # key: elif 3 | # group: Structure 4 | # -- 5 | else if (${1:condition}) { 6 | $0 7 | } -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/else.yasnippet: -------------------------------------------------------------------------------- 1 | # name: else { ... } 2 | # key: else 3 | # group: Structure 4 | # -- 5 | else { 6 | $0 7 | } -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/for.yasnippet: -------------------------------------------------------------------------------- 1 | # name: for (...; ...; ...) { ... } 2 | # key: for 3 | # group: Structure 4 | # -- 5 | for (${1:i} in ${2:1}:${3:N}) { 6 | $0 7 | } 8 | -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/fun.yasnippet: -------------------------------------------------------------------------------- 1 | # name: User-defined function 2 | # key: fun 3 | # group: Blocks 4 | # -- 5 | ${1:return} ${2:name} (${args}) { 6 | $0 7 | } 8 | -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions.yasnippet: -------------------------------------------------------------------------------- 1 | # name: functions {...} 2 | # key: functions 3 | # group: Blocks 4 | # -- 5 | functions { 6 | $0 7 | } 8 | -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/Phi(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: Phi 2 | # key: Phi 3 | # group: Functions 4 | # -- 5 | Phi(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/Phi_approx(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: Phi_approx 2 | # key: Phi_approx 3 | # group: Functions 4 | # -- 5 | Phi_approx(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/abs(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: abs 2 | # key: abs 3 | # group: Functions 4 | # -- 5 | abs(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/acos(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: acos 2 | # key: acos 3 | # group: Functions 4 | # -- 5 | acos(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/acosh(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: acosh 2 | # key: acosh 3 | # group: Functions 4 | # -- 5 | acosh(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/add_diag(m,d).yasnippet: -------------------------------------------------------------------------------- 1 | # name: add_diag 2 | # key: add_diag 3 | # group: Functions 4 | # -- 5 | add_diag(${1:m}, ${2:d})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/algebra_solver(algebra_system,y_guess,theta,x_r,x_i).yasnippet: -------------------------------------------------------------------------------- 1 | # name: algebra_solver 2 | # key: algebra_solver 3 | # group: Functions 4 | # -- 5 | algebra_solver(${1:algebra_system}, ${2:y_guess}, ${3:theta}, ${4:x_r}, ${5:x_i})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/algebra_solver(algebra_system,y_guess,theta,x_r,x_i,rel_tol,f_tol,max_steps).yasnippet: -------------------------------------------------------------------------------- 1 | # name: algebra_solver 2 | # key: algebra_solver 3 | # group: Functions 4 | # -- 5 | algebra_solver(${1:algebra_system}, ${2:y_guess}, ${3:theta}, ${4:x_r}, ${5:x_i}, ${6:rel_tol}, ${7:f_tol}, ${8:max_steps})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/append_array(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: append_array 2 | # key: append_array 3 | # group: Functions 4 | # -- 5 | append_array(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/append_col(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: append_col 2 | # key: append_col 3 | # group: Functions 4 | # -- 5 | append_col(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/append_row(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: append_row 2 | # key: append_row 3 | # group: Functions 4 | # -- 5 | append_row(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/asin(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: asin 2 | # key: asin 3 | # group: Functions 4 | # -- 5 | asin(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/asinh(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: asinh 2 | # key: asinh 3 | # group: Functions 4 | # -- 5 | asinh(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/atan(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: atan 2 | # key: atan 3 | # group: Functions 4 | # -- 5 | atan(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/atan2(y,x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: atan2 2 | # key: atan2 3 | # group: Functions 4 | # -- 5 | atan2(${1:y}, ${2:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/atanh(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: atanh 2 | # key: atanh 3 | # group: Functions 4 | # -- 5 | atanh(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/bernoulli(theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: bernoulli 2 | # key: bernoulli 3 | # group: Distributions 4 | # -- 5 | bernoulli(${1:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/bernoulli_cdf(y,theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: bernoulli_cdf 2 | # key: bernoulli_cdf 3 | # group: Functions 4 | # -- 5 | bernoulli_cdf(${1:y}, ${2:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/bernoulli_lccdf(y,theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: bernoulli_lccdf 2 | # key: bernoulli_lccdf 3 | # group: Functions 4 | # -- 5 | bernoulli_lccdf(${1:y} | ${2:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/bernoulli_lcdf(y,theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: bernoulli_lcdf 2 | # key: bernoulli_lcdf 3 | # group: Functions 4 | # -- 5 | bernoulli_lcdf(${1:y} | ${2:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/bernoulli_logit(alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: bernoulli_logit 2 | # key: bernoulli_logit 3 | # group: Distributions 4 | # -- 5 | bernoulli_logit(${1:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/bernoulli_logit_glm(x,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: bernoulli_logit_glm 2 | # key: bernoulli_logit_glm 3 | # group: Distributions 4 | # -- 5 | bernoulli_logit_glm(${1:x}, ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/bernoulli_logit_glm_lpmf(y,x,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: bernoulli_logit_glm_lpmf 2 | # key: bernoulli_logit_glm_lpmf 3 | # group: Functions 4 | # -- 5 | bernoulli_logit_glm_lpmf(${1:y} | ${2:x}, ${3:alpha}, ${4:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/bernoulli_logit_lpmf(y,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: bernoulli_logit_lpmf 2 | # key: bernoulli_logit_lpmf 3 | # group: Functions 4 | # -- 5 | bernoulli_logit_lpmf(${1:y} | ${2:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/bernoulli_logit_rng(alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: bernoulli_logit_rng 2 | # key: bernoulli_logit_rng 3 | # group: Functions 4 | # -- 5 | bernoulli_logit_rng(${1:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/bernoulli_lpmf(y,theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: bernoulli_lpmf 2 | # key: bernoulli_lpmf 3 | # group: Functions 4 | # -- 5 | bernoulli_lpmf(${1:y} | ${2:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/bernoulli_rng(theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: bernoulli_rng 2 | # key: bernoulli_rng 3 | # group: Functions 4 | # -- 5 | bernoulli_rng(${1:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/bessel_first_kind(v,x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: bessel_first_kind 2 | # key: bessel_first_kind 3 | # group: Functions 4 | # -- 5 | bessel_first_kind(${1:v}, ${2:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/bessel_second_kind(v,x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: bessel_second_kind 2 | # key: bessel_second_kind 3 | # group: Functions 4 | # -- 5 | bessel_second_kind(${1:v}, ${2:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/beta(alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: beta 2 | # key: beta 3 | # group: Distributions 4 | # -- 5 | beta(${1:alpha}, ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/beta_binomial(N,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: beta_binomial 2 | # key: beta_binomial 3 | # group: Distributions 4 | # -- 5 | beta_binomial(${1:N}, ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/beta_binomial_cdf(n,N,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: beta_binomial_cdf 2 | # key: beta_binomial_cdf 3 | # group: Functions 4 | # -- 5 | beta_binomial_cdf(${1:n}, ${2:N}, ${3:alpha}, ${4:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/beta_binomial_lccdf(n,N,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: beta_binomial_lccdf 2 | # key: beta_binomial_lccdf 3 | # group: Functions 4 | # -- 5 | beta_binomial_lccdf(${1:n} | ${2:N}, ${3:alpha}, ${4:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/beta_binomial_lcdf(n,N,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: beta_binomial_lcdf 2 | # key: beta_binomial_lcdf 3 | # group: Functions 4 | # -- 5 | beta_binomial_lcdf(${1:n} | ${2:N}, ${3:alpha}, ${4:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/beta_binomial_lpmf(n,N,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: beta_binomial_lpmf 2 | # key: beta_binomial_lpmf 3 | # group: Functions 4 | # -- 5 | beta_binomial_lpmf(${1:n} | ${2:N}, ${3:alpha}, ${4:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/beta_binomial_rng(N,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: beta_binomial_rng 2 | # key: beta_binomial_rng 3 | # group: Functions 4 | # -- 5 | beta_binomial_rng(${1:N}, ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/beta_cdf(theta,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: beta_cdf 2 | # key: beta_cdf 3 | # group: Functions 4 | # -- 5 | beta_cdf(${1:theta}, ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/beta_lccdf(theta,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: beta_lccdf 2 | # key: beta_lccdf 3 | # group: Functions 4 | # -- 5 | beta_lccdf(${1:theta} | ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/beta_lcdf(theta,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: beta_lcdf 2 | # key: beta_lcdf 3 | # group: Functions 4 | # -- 5 | beta_lcdf(${1:theta} | ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/beta_lpdf(theta,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: beta_lpdf 2 | # key: beta_lpdf 3 | # group: Functions 4 | # -- 5 | beta_lpdf(${1:theta} | ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/beta_proportion_lccdf(theta,mu,kappa).yasnippet: -------------------------------------------------------------------------------- 1 | # name: beta_proportion_lccdf 2 | # key: beta_proportion_lccdf 3 | # group: Functions 4 | # -- 5 | beta_proportion_lccdf(${1:theta} | ${2:mu}, ${3:kappa})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/beta_proportion_lcdf(theta,mu,kappa).yasnippet: -------------------------------------------------------------------------------- 1 | # name: beta_proportion_lcdf 2 | # key: beta_proportion_lcdf 3 | # group: Functions 4 | # -- 5 | beta_proportion_lcdf(${1:theta} | ${2:mu}, ${3:kappa})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/beta_proportion_rng(mu,kappa).yasnippet: -------------------------------------------------------------------------------- 1 | # name: beta_proportion_rng 2 | # key: beta_proportion_rng 3 | # group: Functions 4 | # -- 5 | beta_proportion_rng(${1:mu}, ${2:kappa})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/beta_rng(alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: beta_rng 2 | # key: beta_rng 3 | # group: Functions 4 | # -- 5 | beta_rng(${1:alpha}, ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/binary_log_loss(y,y_hat).yasnippet: -------------------------------------------------------------------------------- 1 | # name: binary_log_loss 2 | # key: binary_log_loss 3 | # group: Functions 4 | # -- 5 | binary_log_loss(${1:y}, ${2:y_hat})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/binomial(N,theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: binomial 2 | # key: binomial 3 | # group: Distributions 4 | # -- 5 | binomial(${1:N}, ${2:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/binomial_cdf(n,N,theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: binomial_cdf 2 | # key: binomial_cdf 3 | # group: Functions 4 | # -- 5 | binomial_cdf(${1:n}, ${2:N}, ${3:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/binomial_coefficient_log(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: binomial_coefficient_log 2 | # key: binomial_coefficient_log 3 | # group: Functions 4 | # -- 5 | binomial_coefficient_log(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/binomial_lccdf(n,N,theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: binomial_lccdf 2 | # key: binomial_lccdf 3 | # group: Functions 4 | # -- 5 | binomial_lccdf(${1:n} | ${2:N}, ${3:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/binomial_lcdf(n,N,theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: binomial_lcdf 2 | # key: binomial_lcdf 3 | # group: Functions 4 | # -- 5 | binomial_lcdf(${1:n} | ${2:N}, ${3:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/binomial_logit(N,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: binomial_logit 2 | # key: binomial_logit 3 | # group: Distributions 4 | # -- 5 | binomial_logit(${1:N}, ${2:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/binomial_logit_lpmf(n,N,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: binomial_logit_lpmf 2 | # key: binomial_logit_lpmf 3 | # group: Functions 4 | # -- 5 | binomial_logit_lpmf(${1:n} | ${2:N}, ${3:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/binomial_lpmf(n,N,theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: binomial_lpmf 2 | # key: binomial_lpmf 3 | # group: Functions 4 | # -- 5 | binomial_lpmf(${1:n} | ${2:N}, ${3:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/binomial_rng(N,theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: binomial_rng 2 | # key: binomial_rng 3 | # group: Functions 4 | # -- 5 | binomial_rng(${1:N}, ${2:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/block(x,i,j,n_rows,n_cols).yasnippet: -------------------------------------------------------------------------------- 1 | # name: block 2 | # key: block 3 | # group: Functions 4 | # -- 5 | block(${1:x}, ${2:i}, ${3:j}, ${4:n_rows}, ${5:n_cols})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/categorical(theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: categorical 2 | # key: categorical 3 | # group: Distributions 4 | # -- 5 | categorical(${1:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/categorical_logit(beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: categorical_logit 2 | # key: categorical_logit 3 | # group: Distributions 4 | # -- 5 | categorical_logit(${1:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/categorical_logit_glm(theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: categorical_logit_glm 2 | # key: categorical_logit_glm 3 | # group: Distributions 4 | # -- 5 | categorical_logit_glm(${1:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/categorical_logit_glm(x,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: categorical_logit_glm 2 | # key: categorical_logit_glm 3 | # group: Distributions 4 | # -- 5 | categorical_logit_glm(${1:x}, ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/categorical_logit_glm_lpmf(y,theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: categorical_logit_glm_lpmf 2 | # key: categorical_logit_glm_lpmf 3 | # group: Functions 4 | # -- 5 | categorical_logit_glm_lpmf(${1:y} | ${2:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/categorical_logit_glm_lpmf(y,x,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: categorical_logit_glm_lpmf 2 | # key: categorical_logit_glm_lpmf 3 | # group: Functions 4 | # -- 5 | categorical_logit_glm_lpmf(${1:y} | ${2:x}, ${3:alpha}, ${4:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/categorical_logit_lpmf(y,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: categorical_logit_lpmf 2 | # key: categorical_logit_lpmf 3 | # group: Functions 4 | # -- 5 | categorical_logit_lpmf(${1:y} | ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/categorical_logit_rng(beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: categorical_logit_rng 2 | # key: categorical_logit_rng 3 | # group: Functions 4 | # -- 5 | categorical_logit_rng(${1:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/categorical_lpmf(y,theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: categorical_lpmf 2 | # key: categorical_lpmf 3 | # group: Functions 4 | # -- 5 | categorical_lpmf(${1:y} | ${2:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/categorical_rng(theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: categorical_rng 2 | # key: categorical_rng 3 | # group: Functions 4 | # -- 5 | categorical_rng(${1:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/cauchy(mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: cauchy 2 | # key: cauchy 3 | # group: Distributions 4 | # -- 5 | cauchy(${1:mu}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/cauchy_cdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: cauchy_cdf 2 | # key: cauchy_cdf 3 | # group: Functions 4 | # -- 5 | cauchy_cdf(${1:y}, ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/cauchy_lccdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: cauchy_lccdf 2 | # key: cauchy_lccdf 3 | # group: Functions 4 | # -- 5 | cauchy_lccdf(${1:y} | ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/cauchy_lcdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: cauchy_lcdf 2 | # key: cauchy_lcdf 3 | # group: Functions 4 | # -- 5 | cauchy_lcdf(${1:y} | ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/cauchy_lpdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: cauchy_lpdf 2 | # key: cauchy_lpdf 3 | # group: Functions 4 | # -- 5 | cauchy_lpdf(${1:y} | ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/cauchy_rng(mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: cauchy_rng 2 | # key: cauchy_rng 3 | # group: Functions 4 | # -- 5 | cauchy_rng(${1:mu}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/cbrt(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: cbrt 2 | # key: cbrt 3 | # group: Functions 4 | # -- 5 | cbrt(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/ceil(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: ceil 2 | # key: ceil 3 | # group: Functions 4 | # -- 5 | ceil(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/chi_square(nu).yasnippet: -------------------------------------------------------------------------------- 1 | # name: chi_square 2 | # key: chi_square 3 | # group: Distributions 4 | # -- 5 | chi_square(${1:nu})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/chi_square_cdf(y,nu).yasnippet: -------------------------------------------------------------------------------- 1 | # name: chi_square_cdf 2 | # key: chi_square_cdf 3 | # group: Functions 4 | # -- 5 | chi_square_cdf(${1:y}, ${2:nu})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/chi_square_lccdf(y,nu).yasnippet: -------------------------------------------------------------------------------- 1 | # name: chi_square_lccdf 2 | # key: chi_square_lccdf 3 | # group: Functions 4 | # -- 5 | chi_square_lccdf(${1:y} | ${2:nu})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/chi_square_lcdf(y,nu).yasnippet: -------------------------------------------------------------------------------- 1 | # name: chi_square_lcdf 2 | # key: chi_square_lcdf 3 | # group: Functions 4 | # -- 5 | chi_square_lcdf(${1:y} | ${2:nu})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/chi_square_lpdf(y,nu).yasnippet: -------------------------------------------------------------------------------- 1 | # name: chi_square_lpdf 2 | # key: chi_square_lpdf 3 | # group: Functions 4 | # -- 5 | chi_square_lpdf(${1:y} | ${2:nu})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/chi_square_rng(nu).yasnippet: -------------------------------------------------------------------------------- 1 | # name: chi_square_rng 2 | # key: chi_square_rng 3 | # group: Functions 4 | # -- 5 | chi_square_rng(${1:nu})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/cholesky_decompose(A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: cholesky_decompose 2 | # key: cholesky_decompose 3 | # group: Functions 4 | # -- 5 | cholesky_decompose(${1:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/choose(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: choose 2 | # key: choose 3 | # group: Functions 4 | # -- 5 | choose(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/col(x,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: col 2 | # key: col 3 | # group: Functions 4 | # -- 5 | col(${1:x}, ${2:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/cols(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: cols 2 | # key: cols 3 | # group: Functions 4 | # -- 5 | cols(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/columns_dot_product(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: columns_dot_product 2 | # key: columns_dot_product 3 | # group: Functions 4 | # -- 5 | columns_dot_product(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/columns_dot_self(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: columns_dot_self 2 | # key: columns_dot_self 3 | # group: Functions 4 | # -- 5 | columns_dot_self(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/cos(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: cos 2 | # key: cos 3 | # group: Functions 4 | # -- 5 | cos(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/cosh(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: cosh 2 | # key: cosh 3 | # group: Functions 4 | # -- 5 | cosh(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/cov_exp_quad(x,alpha,rho).yasnippet: -------------------------------------------------------------------------------- 1 | # name: cov_exp_quad 2 | # key: cov_exp_quad 3 | # group: Functions 4 | # -- 5 | cov_exp_quad(${1:x}, ${2:alpha}, ${3:rho})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/cov_exp_quad(x1,x2,alpha,rho).yasnippet: -------------------------------------------------------------------------------- 1 | # name: cov_exp_quad 2 | # key: cov_exp_quad 3 | # group: Functions 4 | # -- 5 | cov_exp_quad(${1:x1}, ${2:x2}, ${3:alpha}, ${4:rho})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/crossprod(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: crossprod 2 | # key: crossprod 3 | # group: Functions 4 | # -- 5 | crossprod(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/csr_extract_u(a).yasnippet: -------------------------------------------------------------------------------- 1 | # name: csr_extract_u 2 | # key: csr_extract_u 3 | # group: Functions 4 | # -- 5 | csr_extract_u(${1:a})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/csr_extract_v(a).yasnippet: -------------------------------------------------------------------------------- 1 | # name: csr_extract_v 2 | # key: csr_extract_v 3 | # group: Functions 4 | # -- 5 | csr_extract_v(${1:a})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/csr_extract_w(a).yasnippet: -------------------------------------------------------------------------------- 1 | # name: csr_extract_w 2 | # key: csr_extract_w 3 | # group: Functions 4 | # -- 5 | csr_extract_w(${1:a})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/csr_matrix_times_vector(m,n,w,v,u,b).yasnippet: -------------------------------------------------------------------------------- 1 | # name: csr_matrix_times_vector 2 | # key: csr_matrix_times_vector 3 | # group: Functions 4 | # -- 5 | csr_matrix_times_vector(${1:m}, ${2:n}, ${3:w}, ${4:v}, ${5:u}, ${6:b})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/csr_to_dense_matrix(m,n,w,v,u).yasnippet: -------------------------------------------------------------------------------- 1 | # name: csr_to_dense_matrix 2 | # key: csr_to_dense_matrix 3 | # group: Functions 4 | # -- 5 | csr_to_dense_matrix(${1:m}, ${2:n}, ${3:w}, ${4:v}, ${5:u})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/cumulative_sum(rv).yasnippet: -------------------------------------------------------------------------------- 1 | # name: cumulative_sum 2 | # key: cumulative_sum 3 | # group: Functions 4 | # -- 5 | cumulative_sum(${1:rv})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/cumulative_sum(v).yasnippet: -------------------------------------------------------------------------------- 1 | # name: cumulative_sum 2 | # key: cumulative_sum 3 | # group: Functions 4 | # -- 5 | cumulative_sum(${1:v})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/cumulative_sum(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: cumulative_sum 2 | # key: cumulative_sum 3 | # group: Functions 4 | # -- 5 | cumulative_sum(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/determinant(A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: determinant 2 | # key: determinant 3 | # group: Functions 4 | # -- 5 | determinant(${1:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/diag_matrix(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: diag_matrix 2 | # key: diag_matrix 3 | # group: Functions 4 | # -- 5 | diag_matrix(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/diag_post_multiply(m,rv).yasnippet: -------------------------------------------------------------------------------- 1 | # name: diag_post_multiply 2 | # key: diag_post_multiply 3 | # group: Functions 4 | # -- 5 | diag_post_multiply(${1:m}, ${2:rv})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/diag_post_multiply(m,v).yasnippet: -------------------------------------------------------------------------------- 1 | # name: diag_post_multiply 2 | # key: diag_post_multiply 3 | # group: Functions 4 | # -- 5 | diag_post_multiply(${1:m}, ${2:v})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/diag_pre_multiply(rv,m).yasnippet: -------------------------------------------------------------------------------- 1 | # name: diag_pre_multiply 2 | # key: diag_pre_multiply 3 | # group: Functions 4 | # -- 5 | diag_pre_multiply(${1:rv}, ${2:m})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/diag_pre_multiply(v,m).yasnippet: -------------------------------------------------------------------------------- 1 | # name: diag_pre_multiply 2 | # key: diag_pre_multiply 3 | # group: Functions 4 | # -- 5 | diag_pre_multiply(${1:v}, ${2:m})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/diagonal(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: diagonal 2 | # key: diagonal 3 | # group: Functions 4 | # -- 5 | diagonal(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/digamma(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: digamma 2 | # key: digamma 3 | # group: Functions 4 | # -- 5 | digamma(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/dims(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: dims 2 | # key: dims 3 | # group: Functions 4 | # -- 5 | dims(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/dirichlet(alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: dirichlet 2 | # key: dirichlet 3 | # group: Distributions 4 | # -- 5 | dirichlet(${1:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/dirichlet_lpdf(theta,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: dirichlet_lpdf 2 | # key: dirichlet_lpdf 3 | # group: Functions 4 | # -- 5 | dirichlet_lpdf(${1:theta} | ${2:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/dirichlet_rng(alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: dirichlet_rng 2 | # key: dirichlet_rng 3 | # group: Functions 4 | # -- 5 | dirichlet_rng(${1:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/distance(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: distance 2 | # key: distance 3 | # group: Functions 4 | # -- 5 | distance(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/dot_product(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: dot_product 2 | # key: dot_product 3 | # group: Functions 4 | # -- 5 | dot_product(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/dot_self(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: dot_self 2 | # key: dot_self 3 | # group: Functions 4 | # -- 5 | dot_self(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/double_exponential(mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: double_exponential 2 | # key: double_exponential 3 | # group: Distributions 4 | # -- 5 | double_exponential(${1:mu}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/double_exponential_cdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: double_exponential_cdf 2 | # key: double_exponential_cdf 3 | # group: Functions 4 | # -- 5 | double_exponential_cdf(${1:y}, ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/double_exponential_lccdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: double_exponential_lccdf 2 | # key: double_exponential_lccdf 3 | # group: Functions 4 | # -- 5 | double_exponential_lccdf(${1:y} | ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/double_exponential_lcdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: double_exponential_lcdf 2 | # key: double_exponential_lcdf 3 | # group: Functions 4 | # -- 5 | double_exponential_lcdf(${1:y} | ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/double_exponential_lpdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: double_exponential_lpdf 2 | # key: double_exponential_lpdf 3 | # group: Functions 4 | # -- 5 | double_exponential_lpdf(${1:y} | ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/double_exponential_rng(mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: double_exponential_rng 2 | # key: double_exponential_rng 3 | # group: Functions 4 | # -- 5 | double_exponential_rng(${1:mu}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/eigenvalues_sym(A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: eigenvalues_sym 2 | # key: eigenvalues_sym 3 | # group: Functions 4 | # -- 5 | eigenvalues_sym(${1:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/eigenvectors_sym(A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: eigenvectors_sym 2 | # key: eigenvectors_sym 3 | # group: Functions 4 | # -- 5 | eigenvectors_sym(${1:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/erf(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: erf 2 | # key: erf 3 | # group: Functions 4 | # -- 5 | erf(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/erfc(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: erfc 2 | # key: erfc 3 | # group: Functions 4 | # -- 5 | erfc(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/exp(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: exp 2 | # key: exp 3 | # group: Functions 4 | # -- 5 | exp(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/exp2(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: exp2 2 | # key: exp2 3 | # group: Functions 4 | # -- 5 | exp2(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/exp_mod_normal(mu,sigma,lambda).yasnippet: -------------------------------------------------------------------------------- 1 | # name: exp_mod_normal 2 | # key: exp_mod_normal 3 | # group: Distributions 4 | # -- 5 | exp_mod_normal(${1:mu}, ${2:sigma}, ${3:lambda})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/exp_mod_normal_cdf(y,mu,sigma,lambda).yasnippet: -------------------------------------------------------------------------------- 1 | # name: exp_mod_normal_cdf 2 | # key: exp_mod_normal_cdf 3 | # group: Functions 4 | # -- 5 | exp_mod_normal_cdf(${1:y}, ${2:mu}, ${3:sigma}, ${4:lambda})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/exp_mod_normal_lccdf(y,mu,sigma,lambda).yasnippet: -------------------------------------------------------------------------------- 1 | # name: exp_mod_normal_lccdf 2 | # key: exp_mod_normal_lccdf 3 | # group: Functions 4 | # -- 5 | exp_mod_normal_lccdf(${1:y} | ${2:mu}, ${3:sigma}, ${4:lambda})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/exp_mod_normal_lcdf(y,mu,sigma,lambda).yasnippet: -------------------------------------------------------------------------------- 1 | # name: exp_mod_normal_lcdf 2 | # key: exp_mod_normal_lcdf 3 | # group: Functions 4 | # -- 5 | exp_mod_normal_lcdf(${1:y} | ${2:mu}, ${3:sigma}, ${4:lambda})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/exp_mod_normal_lpdf(y,mu,sigma,lambda).yasnippet: -------------------------------------------------------------------------------- 1 | # name: exp_mod_normal_lpdf 2 | # key: exp_mod_normal_lpdf 3 | # group: Functions 4 | # -- 5 | exp_mod_normal_lpdf(${1:y} | ${2:mu}, ${3:sigma}, ${4:lambda})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/exp_mod_normal_rng(mu,sigma,lambda).yasnippet: -------------------------------------------------------------------------------- 1 | # name: exp_mod_normal_rng 2 | # key: exp_mod_normal_rng 3 | # group: Functions 4 | # -- 5 | exp_mod_normal_rng(${1:mu}, ${2:sigma}, ${3:lambda})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/expm1(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: expm1 2 | # key: expm1 3 | # group: Functions 4 | # -- 5 | expm1(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/exponential(beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: exponential 2 | # key: exponential 3 | # group: Distributions 4 | # -- 5 | exponential(${1:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/exponential_cdf(y,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: exponential_cdf 2 | # key: exponential_cdf 3 | # group: Functions 4 | # -- 5 | exponential_cdf(${1:y}, ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/exponential_lccdf(y,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: exponential_lccdf 2 | # key: exponential_lccdf 3 | # group: Functions 4 | # -- 5 | exponential_lccdf(${1:y} | ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/exponential_lcdf(y,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: exponential_lcdf 2 | # key: exponential_lcdf 3 | # group: Functions 4 | # -- 5 | exponential_lcdf(${1:y} | ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/exponential_lpdf(y,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: exponential_lpdf 2 | # key: exponential_lpdf 3 | # group: Functions 4 | # -- 5 | exponential_lpdf(${1:y} | ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/exponential_rng(beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: exponential_rng 2 | # key: exponential_rng 3 | # group: Functions 4 | # -- 5 | exponential_rng(${1:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/fabs(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: fabs 2 | # key: fabs 3 | # group: Functions 4 | # -- 5 | fabs(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/falling_factorial(x,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: falling_factorial 2 | # key: falling_factorial 3 | # group: Functions 4 | # -- 5 | falling_factorial(${1:x}, ${2:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/fdim(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: fdim 2 | # key: fdim 3 | # group: Functions 4 | # -- 5 | fdim(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/floor(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: floor 2 | # key: floor 3 | # group: Functions 4 | # -- 5 | floor(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/fma(x,y,z).yasnippet: -------------------------------------------------------------------------------- 1 | # name: fma 2 | # key: fma 3 | # group: Functions 4 | # -- 5 | fma(${1:x}, ${2:y}, ${3:z})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/fmax(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: fmax 2 | # key: fmax 3 | # group: Functions 4 | # -- 5 | fmax(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/fmin(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: fmin 2 | # key: fmin 3 | # group: Functions 4 | # -- 5 | fmin(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/fmod(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: fmod 2 | # key: fmod 3 | # group: Functions 4 | # -- 5 | fmod(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/frechet(alpha,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: frechet 2 | # key: frechet 3 | # group: Distributions 4 | # -- 5 | frechet(${1:alpha}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/frechet_cdf(y,alpha,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: frechet_cdf 2 | # key: frechet_cdf 3 | # group: Functions 4 | # -- 5 | frechet_cdf(${1:y}, ${2:alpha}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/frechet_lccdf(y,alpha,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: frechet_lccdf 2 | # key: frechet_lccdf 3 | # group: Functions 4 | # -- 5 | frechet_lccdf(${1:y} | ${2:alpha}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/frechet_lcdf(y,alpha,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: frechet_lcdf 2 | # key: frechet_lcdf 3 | # group: Functions 4 | # -- 5 | frechet_lcdf(${1:y} | ${2:alpha}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/frechet_lpdf(y,alpha,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: frechet_lpdf 2 | # key: frechet_lpdf 3 | # group: Functions 4 | # -- 5 | frechet_lpdf(${1:y} | ${2:alpha}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/frechet_rng(alpha,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: frechet_rng 2 | # key: frechet_rng 3 | # group: Functions 4 | # -- 5 | frechet_rng(${1:alpha}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/gamma(alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: gamma 2 | # key: gamma 3 | # group: Distributions 4 | # -- 5 | gamma(${1:alpha}, ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/gamma_cdf(y,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: gamma_cdf 2 | # key: gamma_cdf 3 | # group: Functions 4 | # -- 5 | gamma_cdf(${1:y}, ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/gamma_lccdf(y,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: gamma_lccdf 2 | # key: gamma_lccdf 3 | # group: Functions 4 | # -- 5 | gamma_lccdf(${1:y} | ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/gamma_lcdf(y,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: gamma_lcdf 2 | # key: gamma_lcdf 3 | # group: Functions 4 | # -- 5 | gamma_lcdf(${1:y} | ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/gamma_lpdf(y,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: gamma_lpdf 2 | # key: gamma_lpdf 3 | # group: Functions 4 | # -- 5 | gamma_lpdf(${1:y} | ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/gamma_p(a,z).yasnippet: -------------------------------------------------------------------------------- 1 | # name: gamma_p 2 | # key: gamma_p 3 | # group: Functions 4 | # -- 5 | gamma_p(${1:a}, ${2:z})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/gamma_q(a,z).yasnippet: -------------------------------------------------------------------------------- 1 | # name: gamma_q 2 | # key: gamma_q 3 | # group: Functions 4 | # -- 5 | gamma_q(${1:a}, ${2:z})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/gamma_rng(alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: gamma_rng 2 | # key: gamma_rng 3 | # group: Functions 4 | # -- 5 | gamma_rng(${1:alpha}, ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/gaussian_dlm_obs(F,G,V,W,m0,C0).yasnippet: -------------------------------------------------------------------------------- 1 | # name: gaussian_dlm_obs 2 | # key: gaussian_dlm_obs 3 | # group: Distributions 4 | # -- 5 | gaussian_dlm_obs(${1:F}, ${2:G}, ${3:V}, ${4:W}, ${5:m0}, ${6:C0})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/gaussian_dlm_obs_lpdf(y,F,G,V,W,m0,C0).yasnippet: -------------------------------------------------------------------------------- 1 | # name: gaussian_dlm_obs_lpdf 2 | # key: gaussian_dlm_obs_lpdf 3 | # group: Functions 4 | # -- 5 | gaussian_dlm_obs_lpdf(${1:y} | ${2:F}, ${3:G}, ${4:V}, ${5:W}, ${6:m0}, ${7:C0})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/gumbel(mu,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: gumbel 2 | # key: gumbel 3 | # group: Distributions 4 | # -- 5 | gumbel(${1:mu}, ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/gumbel_cdf(y,mu,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: gumbel_cdf 2 | # key: gumbel_cdf 3 | # group: Functions 4 | # -- 5 | gumbel_cdf(${1:y}, ${2:mu}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/gumbel_lccdf(y,mu,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: gumbel_lccdf 2 | # key: gumbel_lccdf 3 | # group: Functions 4 | # -- 5 | gumbel_lccdf(${1:y} | ${2:mu}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/gumbel_lcdf(y,mu,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: gumbel_lcdf 2 | # key: gumbel_lcdf 3 | # group: Functions 4 | # -- 5 | gumbel_lcdf(${1:y} | ${2:mu}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/gumbel_lpdf(y,mu,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: gumbel_lpdf 2 | # key: gumbel_lpdf 3 | # group: Functions 4 | # -- 5 | gumbel_lpdf(${1:y} | ${2:mu}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/gumbel_rng(mu,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: gumbel_rng 2 | # key: gumbel_rng 3 | # group: Functions 4 | # -- 5 | gumbel_rng(${1:mu}, ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/head(rv,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: head 2 | # key: head 3 | # group: Functions 4 | # -- 5 | head(${1:rv}, ${2:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/head(sv,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: head 2 | # key: head 3 | # group: Functions 4 | # -- 5 | head(${1:sv}, ${2:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/head(v,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: head 2 | # key: head 3 | # group: Functions 4 | # -- 5 | head(${1:v}, ${2:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/hypergeometric(N,a,b).yasnippet: -------------------------------------------------------------------------------- 1 | # name: hypergeometric 2 | # key: hypergeometric 3 | # group: Distributions 4 | # -- 5 | hypergeometric(${1:N}, ${2:a}, ${3:b})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/hypergeometric_lpmf(n,N,a,b).yasnippet: -------------------------------------------------------------------------------- 1 | # name: hypergeometric_lpmf 2 | # key: hypergeometric_lpmf 3 | # group: Functions 4 | # -- 5 | hypergeometric_lpmf(${1:n} | ${2:N}, ${3:a}, ${4:b})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/hypergeometric_rng(N,a,b).yasnippet: -------------------------------------------------------------------------------- 1 | # name: hypergeometric_rng 2 | # key: hypergeometric_rng 3 | # group: Functions 4 | # -- 5 | hypergeometric_rng(${1:N}, ${2:a}, ${3:b})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/hypot(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: hypot 2 | # key: hypot 3 | # group: Functions 4 | # -- 5 | hypot(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inc_beta(alpha,beta,x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inc_beta 2 | # key: inc_beta 3 | # group: Functions 4 | # -- 5 | inc_beta(${1:alpha}, ${2:beta}, ${3:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/int_step(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: int_step 2 | # key: int_step 3 | # group: Functions 4 | # -- 5 | int_step(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/integrate_1d(integrand,a,b,theta,x_r,x_i).yasnippet: -------------------------------------------------------------------------------- 1 | # name: integrate_1d 2 | # key: integrate_1d 3 | # group: Functions 4 | # -- 5 | integrate_1d(${1:integrand}, ${2:a}, ${3:b}, ${4:theta}, ${5:x_r}, ${6:x_i})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/integrate_1d(integrand,a,b,theta,x_r,x_i,relative_tolerance).yasnippet: -------------------------------------------------------------------------------- 1 | # name: integrate_1d 2 | # key: integrate_1d 3 | # group: Functions 4 | # -- 5 | integrate_1d(${1:integrand}, ${2:a}, ${3:b}, ${4:theta}, ${5:x_r}, ${6:x_i}, ${7:relative_tolerance})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv 2 | # key: inv 3 | # group: Functions 4 | # -- 5 | inv(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_Phi(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_Phi 2 | # key: inv_Phi 3 | # group: Functions 4 | # -- 5 | inv_Phi(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_chi_square(nu).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_chi_square 2 | # key: inv_chi_square 3 | # group: Distributions 4 | # -- 5 | inv_chi_square(${1:nu})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_chi_square_cdf(y,nu).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_chi_square_cdf 2 | # key: inv_chi_square_cdf 3 | # group: Functions 4 | # -- 5 | inv_chi_square_cdf(${1:y}, ${2:nu})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_chi_square_lccdf(y,nu).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_chi_square_lccdf 2 | # key: inv_chi_square_lccdf 3 | # group: Functions 4 | # -- 5 | inv_chi_square_lccdf(${1:y} | ${2:nu})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_chi_square_lcdf(y,nu).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_chi_square_lcdf 2 | # key: inv_chi_square_lcdf 3 | # group: Functions 4 | # -- 5 | inv_chi_square_lcdf(${1:y} | ${2:nu})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_chi_square_lpdf(y,nu).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_chi_square_lpdf 2 | # key: inv_chi_square_lpdf 3 | # group: Functions 4 | # -- 5 | inv_chi_square_lpdf(${1:y} | ${2:nu})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_chi_square_rng(nu).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_chi_square_rng 2 | # key: inv_chi_square_rng 3 | # group: Functions 4 | # -- 5 | inv_chi_square_rng(${1:nu})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_cloglog(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_cloglog 2 | # key: inv_cloglog 3 | # group: Functions 4 | # -- 5 | inv_cloglog(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_gamma(alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_gamma 2 | # key: inv_gamma 3 | # group: Distributions 4 | # -- 5 | inv_gamma(${1:alpha}, ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_gamma_cdf(y,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_gamma_cdf 2 | # key: inv_gamma_cdf 3 | # group: Functions 4 | # -- 5 | inv_gamma_cdf(${1:y}, ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_gamma_lccdf(y,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_gamma_lccdf 2 | # key: inv_gamma_lccdf 3 | # group: Functions 4 | # -- 5 | inv_gamma_lccdf(${1:y} | ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_gamma_lcdf(y,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_gamma_lcdf 2 | # key: inv_gamma_lcdf 3 | # group: Functions 4 | # -- 5 | inv_gamma_lcdf(${1:y} | ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_gamma_lpdf(y,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_gamma_lpdf 2 | # key: inv_gamma_lpdf 3 | # group: Functions 4 | # -- 5 | inv_gamma_lpdf(${1:y} | ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_gamma_rng(alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_gamma_rng 2 | # key: inv_gamma_rng 3 | # group: Functions 4 | # -- 5 | inv_gamma_rng(${1:alpha}, ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_logit(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_logit 2 | # key: inv_logit 3 | # group: Functions 4 | # -- 5 | inv_logit(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_sqrt(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_sqrt 2 | # key: inv_sqrt 3 | # group: Functions 4 | # -- 5 | inv_sqrt(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_square(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_square 2 | # key: inv_square 3 | # group: Functions 4 | # -- 5 | inv_square(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_wishart(nu,Sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_wishart 2 | # key: inv_wishart 3 | # group: Distributions 4 | # -- 5 | inv_wishart(${1:nu}, ${2:Sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_wishart_lpdf(W,nu,Sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_wishart_lpdf 2 | # key: inv_wishart_lpdf 3 | # group: Functions 4 | # -- 5 | inv_wishart_lpdf(${1:W} | ${2:nu}, ${3:Sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inv_wishart_rng(nu,Sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inv_wishart_rng 2 | # key: inv_wishart_rng 3 | # group: Functions 4 | # -- 5 | inv_wishart_rng(${1:nu}, ${2:Sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inverse(A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inverse 2 | # key: inverse 3 | # group: Functions 4 | # -- 5 | inverse(${1:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/inverse_spd(A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: inverse_spd 2 | # key: inverse_spd 3 | # group: Functions 4 | # -- 5 | inverse_spd(${1:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/is_inf(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: is_inf 2 | # key: is_inf 3 | # group: Functions 4 | # -- 5 | is_inf(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/is_nan(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: is_nan 2 | # key: is_nan 3 | # group: Functions 4 | # -- 5 | is_nan(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lbeta(alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lbeta 2 | # key: lbeta 3 | # group: Functions 4 | # -- 5 | lbeta(${1:alpha}, ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lchoose(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lchoose 2 | # key: lchoose 3 | # group: Functions 4 | # -- 5 | lchoose(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lgamma(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lgamma 2 | # key: lgamma 3 | # group: Functions 4 | # -- 5 | lgamma(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lkj_corr(eta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lkj_corr 2 | # key: lkj_corr 3 | # group: Distributions 4 | # -- 5 | lkj_corr(${1:eta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lkj_corr_cholesky(eta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lkj_corr_cholesky 2 | # key: lkj_corr_cholesky 3 | # group: Distributions 4 | # -- 5 | lkj_corr_cholesky(${1:eta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lkj_corr_cholesky_lpdf(L,eta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lkj_corr_cholesky_lpdf 2 | # key: lkj_corr_cholesky_lpdf 3 | # group: Functions 4 | # -- 5 | lkj_corr_cholesky_lpdf(${1:L} | ${2:eta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lkj_corr_cholesky_rng(K,eta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lkj_corr_cholesky_rng 2 | # key: lkj_corr_cholesky_rng 3 | # group: Functions 4 | # -- 5 | lkj_corr_cholesky_rng(${1:K}, ${2:eta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lkj_corr_lpdf(y,eta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lkj_corr_lpdf 2 | # key: lkj_corr_lpdf 3 | # group: Functions 4 | # -- 5 | lkj_corr_lpdf(${1:y} | ${2:eta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lkj_corr_rng(K,eta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lkj_corr_rng 2 | # key: lkj_corr_rng 3 | # group: Functions 4 | # -- 5 | lkj_corr_rng(${1:K}, ${2:eta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lmgamma(n,x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lmgamma 2 | # key: lmgamma 3 | # group: Functions 4 | # -- 5 | lmgamma(${1:n}, ${2:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lmultiply(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lmultiply 2 | # key: lmultiply 3 | # group: Functions 4 | # -- 5 | lmultiply(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log 2 | # key: log 3 | # group: Functions 4 | # -- 5 | log(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log10(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log10 2 | # key: log10 3 | # group: Functions 4 | # -- 5 | log10(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log1m(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log1m 2 | # key: log1m 3 | # group: Functions 4 | # -- 5 | log1m(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log1m_exp(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log1m_exp 2 | # key: log1m_exp 3 | # group: Functions 4 | # -- 5 | log1m_exp(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log1m_inv_logit(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log1m_inv_logit 2 | # key: log1m_inv_logit 3 | # group: Functions 4 | # -- 5 | log1m_inv_logit(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log1p(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log1p 2 | # key: log1p 3 | # group: Functions 4 | # -- 5 | log1p(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log1p_exp(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log1p_exp 2 | # key: log1p_exp 3 | # group: Functions 4 | # -- 5 | log1p_exp(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log2(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log2 2 | # key: log2 3 | # group: Functions 4 | # -- 5 | log2(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log_determinant(A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log_determinant 2 | # key: log_determinant 3 | # group: Functions 4 | # -- 5 | log_determinant(${1:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log_diff_exp(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log_diff_exp 2 | # key: log_diff_exp 3 | # group: Functions 4 | # -- 5 | log_diff_exp(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log_falling_factorial(x,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log_falling_factorial 2 | # key: log_falling_factorial 3 | # group: Functions 4 | # -- 5 | log_falling_factorial(${1:x}, ${2:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log_inv_logit(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log_inv_logit 2 | # key: log_inv_logit 3 | # group: Functions 4 | # -- 5 | log_inv_logit(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log_mix(theta,lp1,lp2).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log_mix 2 | # key: log_mix 3 | # group: Functions 4 | # -- 5 | log_mix(${1:theta}, ${2:lp1}, ${3:lp2})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log_rising_factorial(x,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log_rising_factorial 2 | # key: log_rising_factorial 3 | # group: Functions 4 | # -- 5 | log_rising_factorial(${1:x}, ${2:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log_softmax(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log_softmax 2 | # key: log_softmax 3 | # group: Functions 4 | # -- 5 | log_softmax(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log_sum_exp(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log_sum_exp 2 | # key: log_sum_exp 3 | # group: Functions 4 | # -- 5 | log_sum_exp(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/log_sum_exp(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: log_sum_exp 2 | # key: log_sum_exp 3 | # group: Functions 4 | # -- 5 | log_sum_exp(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/logistic(mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: logistic 2 | # key: logistic 3 | # group: Distributions 4 | # -- 5 | logistic(${1:mu}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/logistic_cdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: logistic_cdf 2 | # key: logistic_cdf 3 | # group: Functions 4 | # -- 5 | logistic_cdf(${1:y}, ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/logistic_lccdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: logistic_lccdf 2 | # key: logistic_lccdf 3 | # group: Functions 4 | # -- 5 | logistic_lccdf(${1:y} | ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/logistic_lcdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: logistic_lcdf 2 | # key: logistic_lcdf 3 | # group: Functions 4 | # -- 5 | logistic_lcdf(${1:y} | ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/logistic_lpdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: logistic_lpdf 2 | # key: logistic_lpdf 3 | # group: Functions 4 | # -- 5 | logistic_lpdf(${1:y} | ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/logistic_rng(mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: logistic_rng 2 | # key: logistic_rng 3 | # group: Functions 4 | # -- 5 | logistic_rng(${1:mu}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/logit(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: logit 2 | # key: logit 3 | # group: Functions 4 | # -- 5 | logit(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lognormal(mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lognormal 2 | # key: lognormal 3 | # group: Distributions 4 | # -- 5 | lognormal(${1:mu}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lognormal_cdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lognormal_cdf 2 | # key: lognormal_cdf 3 | # group: Functions 4 | # -- 5 | lognormal_cdf(${1:y}, ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lognormal_lccdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lognormal_lccdf 2 | # key: lognormal_lccdf 3 | # group: Functions 4 | # -- 5 | lognormal_lccdf(${1:y} | ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lognormal_lcdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lognormal_lcdf 2 | # key: lognormal_lcdf 3 | # group: Functions 4 | # -- 5 | lognormal_lcdf(${1:y} | ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lognormal_lpdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lognormal_lpdf 2 | # key: lognormal_lpdf 3 | # group: Functions 4 | # -- 5 | lognormal_lpdf(${1:y} | ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/lognormal_rng(mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: lognormal_rng 2 | # key: lognormal_rng 3 | # group: Functions 4 | # -- 5 | lognormal_rng(${1:mu}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/map_rect(f,phi,theta,x_r,x_i).yasnippet: -------------------------------------------------------------------------------- 1 | # name: map_rect 2 | # key: map_rect 3 | # group: Functions 4 | # -- 5 | map_rect(${1:f}, ${2:phi}, ${3:theta}, ${4:x_r}, ${5:x_i})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/matrix_exp(A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: matrix_exp 2 | # key: matrix_exp 3 | # group: Functions 4 | # -- 5 | matrix_exp(${1:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/matrix_exp_multiply(A,B).yasnippet: -------------------------------------------------------------------------------- 1 | # name: matrix_exp_multiply 2 | # key: matrix_exp_multiply 3 | # group: Functions 4 | # -- 5 | matrix_exp_multiply(${1:A}, ${2:B})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/matrix_power(A,B).yasnippet: -------------------------------------------------------------------------------- 1 | # name: matrix_power 2 | # key: matrix_power 3 | # group: Functions 4 | # -- 5 | matrix_power(${1:A}, ${2:B})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/max(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: max 2 | # key: max 3 | # group: Functions 4 | # -- 5 | max(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/max(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: max 2 | # key: max 3 | # group: Functions 4 | # -- 5 | max(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/mdivide_left_spd(A,B).yasnippet: -------------------------------------------------------------------------------- 1 | # name: mdivide_left_spd 2 | # key: mdivide_left_spd 3 | # group: Functions 4 | # -- 5 | mdivide_left_spd(${1:A}, ${2:B})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/mdivide_left_spd(A,b).yasnippet: -------------------------------------------------------------------------------- 1 | # name: mdivide_left_spd 2 | # key: mdivide_left_spd 3 | # group: Functions 4 | # -- 5 | mdivide_left_spd(${1:A}, ${2:b})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/mdivide_left_tri_low(A,B).yasnippet: -------------------------------------------------------------------------------- 1 | # name: mdivide_left_tri_low 2 | # key: mdivide_left_tri_low 3 | # group: Functions 4 | # -- 5 | mdivide_left_tri_low(${1:A}, ${2:B})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/mdivide_left_tri_low(A,b).yasnippet: -------------------------------------------------------------------------------- 1 | # name: mdivide_left_tri_low 2 | # key: mdivide_left_tri_low 3 | # group: Functions 4 | # -- 5 | mdivide_left_tri_low(${1:A}, ${2:b})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/mdivide_right_spd(B,A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: mdivide_right_spd 2 | # key: mdivide_right_spd 3 | # group: Functions 4 | # -- 5 | mdivide_right_spd(${1:B}, ${2:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/mdivide_right_spd(b,A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: mdivide_right_spd 2 | # key: mdivide_right_spd 3 | # group: Functions 4 | # -- 5 | mdivide_right_spd(${1:b}, ${2:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/mdivide_right_tri_low(B,A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: mdivide_right_tri_low 2 | # key: mdivide_right_tri_low 3 | # group: Functions 4 | # -- 5 | mdivide_right_tri_low(${1:B}, ${2:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/mdivide_right_tri_low(b,A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: mdivide_right_tri_low 2 | # key: mdivide_right_tri_low 3 | # group: Functions 4 | # -- 5 | mdivide_right_tri_low(${1:b}, ${2:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/mean(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: mean 2 | # key: mean 3 | # group: Functions 4 | # -- 5 | mean(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/min(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: min 2 | # key: min 3 | # group: Functions 4 | # -- 5 | min(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/min(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: min 2 | # key: min 3 | # group: Functions 4 | # -- 5 | min(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/modified_bessel_first_kind(v,z).yasnippet: -------------------------------------------------------------------------------- 1 | # name: modified_bessel_first_kind 2 | # key: modified_bessel_first_kind 3 | # group: Functions 4 | # -- 5 | modified_bessel_first_kind(${1:v}, ${2:z})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/modified_bessel_second_kind(v,z).yasnippet: -------------------------------------------------------------------------------- 1 | # name: modified_bessel_second_kind 2 | # key: modified_bessel_second_kind 3 | # group: Functions 4 | # -- 5 | modified_bessel_second_kind(${1:v}, ${2:z})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multi_gp(Sigma,w).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multi_gp 2 | # key: multi_gp 3 | # group: Distributions 4 | # -- 5 | multi_gp(${1:Sigma}, ${2:w})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multi_gp_cholesky(L,w).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multi_gp_cholesky 2 | # key: multi_gp_cholesky 3 | # group: Distributions 4 | # -- 5 | multi_gp_cholesky(${1:L}, ${2:w})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multi_gp_cholesky_lpdf(y,L,w).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multi_gp_cholesky_lpdf 2 | # key: multi_gp_cholesky_lpdf 3 | # group: Functions 4 | # -- 5 | multi_gp_cholesky_lpdf(${1:y} | ${2:L}, ${3:w})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multi_gp_lpdf(y,Sigma,w).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multi_gp_lpdf 2 | # key: multi_gp_lpdf 3 | # group: Functions 4 | # -- 5 | multi_gp_lpdf(${1:y} | ${2:Sigma}, ${3:w})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multi_normal(mu,Sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multi_normal 2 | # key: multi_normal 3 | # group: Distributions 4 | # -- 5 | multi_normal(${1:mu}, ${2:Sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multi_normal_cholesky(mu,L).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multi_normal_cholesky 2 | # key: multi_normal_cholesky 3 | # group: Distributions 4 | # -- 5 | multi_normal_cholesky(${1:mu}, ${2:L})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multi_normal_cholesky_lpdf(y,mu,L).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multi_normal_cholesky_lpdf 2 | # key: multi_normal_cholesky_lpdf 3 | # group: Functions 4 | # -- 5 | multi_normal_cholesky_lpdf(${1:y} | ${2:mu}, ${3:L})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multi_normal_cholesky_rng(mu,L).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multi_normal_cholesky_rng 2 | # key: multi_normal_cholesky_rng 3 | # group: Functions 4 | # -- 5 | multi_normal_cholesky_rng(${1:mu}, ${2:L})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multi_normal_lpdf(y,mu,Sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multi_normal_lpdf 2 | # key: multi_normal_lpdf 3 | # group: Functions 4 | # -- 5 | multi_normal_lpdf(${1:y} | ${2:mu}, ${3:Sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multi_normal_prec(mu,Omega).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multi_normal_prec 2 | # key: multi_normal_prec 3 | # group: Distributions 4 | # -- 5 | multi_normal_prec(${1:mu}, ${2:Omega})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multi_normal_prec_lpdf(y,mu,Omega).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multi_normal_prec_lpdf 2 | # key: multi_normal_prec_lpdf 3 | # group: Functions 4 | # -- 5 | multi_normal_prec_lpdf(${1:y} | ${2:mu}, ${3:Omega})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multi_normal_rng(mu,Sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multi_normal_rng 2 | # key: multi_normal_rng 3 | # group: Functions 4 | # -- 5 | multi_normal_rng(${1:mu}, ${2:Sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multi_student_t(nu,mu,Sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multi_student_t 2 | # key: multi_student_t 3 | # group: Distributions 4 | # -- 5 | multi_student_t(${1:nu}, ${2:mu}, ${3:Sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multi_student_t_lpdf(y,nu,mu,Sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multi_student_t_lpdf 2 | # key: multi_student_t_lpdf 3 | # group: Functions 4 | # -- 5 | multi_student_t_lpdf(${1:y} | ${2:nu}, ${3:mu}, ${4:Sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multi_student_t_rng(nu,mu,Sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multi_student_t_rng 2 | # key: multi_student_t_rng 3 | # group: Functions 4 | # -- 5 | multi_student_t_rng(${1:nu}, ${2:mu}, ${3:Sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multinomial(theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multinomial 2 | # key: multinomial 3 | # group: Distributions 4 | # -- 5 | multinomial(${1:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multinomial_logit(theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multinomial_logit 2 | # key: multinomial_logit 3 | # group: Distributions 4 | # -- 5 | multinomial_logit(${1:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multinomial_logit_lpmf(y,theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multinomial_logit_lpmf 2 | # key: multinomial_logit_lpmf 3 | # group: Functions 4 | # -- 5 | multinomial_logit_lpmf(${1:y} | ${2:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multinomial_logit_rng(theta,N).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multinomial_logit_rng 2 | # key: multinomial_logit_rng 3 | # group: Functions 4 | # -- 5 | multinomial_logit_rng(${1:theta}, ${2:N})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multinomial_lpmf(y,theta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multinomial_lpmf 2 | # key: multinomial_lpmf 3 | # group: Functions 4 | # -- 5 | multinomial_lpmf(${1:y} | ${2:theta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multinomial_rng(theta,N).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multinomial_rng 2 | # key: multinomial_rng 3 | # group: Functions 4 | # -- 5 | multinomial_rng(${1:theta}, ${2:N})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multiply_log(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multiply_log 2 | # key: multiply_log 3 | # group: Functions 4 | # -- 5 | multiply_log(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/multiply_lower_tri_self_transpose(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: multiply_lower_tri_self_transpose 2 | # key: multiply_lower_tri_self_transpose 3 | # group: Functions 4 | # -- 5 | multiply_lower_tri_self_transpose(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial(alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial 2 | # key: neg_binomial 3 | # group: Distributions 4 | # -- 5 | neg_binomial(${1:alpha}, ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial_2(mu,phi).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial_2 2 | # key: neg_binomial_2 3 | # group: Distributions 4 | # -- 5 | neg_binomial_2(${1:mu}, ${2:phi})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial_2_cdf(n,mu,phi).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial_2_cdf 2 | # key: neg_binomial_2_cdf 3 | # group: Functions 4 | # -- 5 | neg_binomial_2_cdf(${1:n}, ${2:mu}, ${3:phi})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial_2_lccdf(n,mu,phi).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial_2_lccdf 2 | # key: neg_binomial_2_lccdf 3 | # group: Functions 4 | # -- 5 | neg_binomial_2_lccdf(${1:n} | ${2:mu}, ${3:phi})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial_2_lcdf(n,mu,phi).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial_2_lcdf 2 | # key: neg_binomial_2_lcdf 3 | # group: Functions 4 | # -- 5 | neg_binomial_2_lcdf(${1:n} | ${2:mu}, ${3:phi})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial_2_log(eta,phi).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial_2_log 2 | # key: neg_binomial_2_log 3 | # group: Distributions 4 | # -- 5 | neg_binomial_2_log(${1:eta}, ${2:phi})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial_2_log_glm(x,alpha,beta,phi).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial_2_log_glm 2 | # key: neg_binomial_2_log_glm 3 | # group: Distributions 4 | # -- 5 | neg_binomial_2_log_glm(${1:x}, ${2:alpha}, ${3:beta}, ${4:phi})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial_2_log_glm_lpmf(y,x,alpha,beta,phi).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial_2_log_glm_lpmf 2 | # key: neg_binomial_2_log_glm_lpmf 3 | # group: Functions 4 | # -- 5 | neg_binomial_2_log_glm_lpmf(${1:y} | ${2:x}, ${3:alpha}, ${4:beta}, ${5:phi})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial_2_log_lpmf(n,eta,phi).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial_2_log_lpmf 2 | # key: neg_binomial_2_log_lpmf 3 | # group: Functions 4 | # -- 5 | neg_binomial_2_log_lpmf(${1:n} | ${2:eta}, ${3:phi})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial_2_log_rng(eta,phi).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial_2_log_rng 2 | # key: neg_binomial_2_log_rng 3 | # group: Functions 4 | # -- 5 | neg_binomial_2_log_rng(${1:eta}, ${2:phi})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial_2_lpmf(n,mu,phi).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial_2_lpmf 2 | # key: neg_binomial_2_lpmf 3 | # group: Functions 4 | # -- 5 | neg_binomial_2_lpmf(${1:n} | ${2:mu}, ${3:phi})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial_2_rng(mu,phi).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial_2_rng 2 | # key: neg_binomial_2_rng 3 | # group: Functions 4 | # -- 5 | neg_binomial_2_rng(${1:mu}, ${2:phi})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial_cdf(n,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial_cdf 2 | # key: neg_binomial_cdf 3 | # group: Functions 4 | # -- 5 | neg_binomial_cdf(${1:n}, ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial_lccdf(n,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial_lccdf 2 | # key: neg_binomial_lccdf 3 | # group: Functions 4 | # -- 5 | neg_binomial_lccdf(${1:n} | ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial_lcdf(n,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial_lcdf 2 | # key: neg_binomial_lcdf 3 | # group: Functions 4 | # -- 5 | neg_binomial_lcdf(${1:n} | ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial_lpmf(n,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial_lpmf 2 | # key: neg_binomial_lpmf 3 | # group: Functions 4 | # -- 5 | neg_binomial_lpmf(${1:n} | ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/neg_binomial_rng(alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: neg_binomial_rng 2 | # key: neg_binomial_rng 3 | # group: Functions 4 | # -- 5 | neg_binomial_rng(${1:alpha}, ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/normal(mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: normal 2 | # key: normal 3 | # group: Distributions 4 | # -- 5 | normal(${1:mu}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/normal_cdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: normal_cdf 2 | # key: normal_cdf 3 | # group: Functions 4 | # -- 5 | normal_cdf(${1:y}, ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/normal_id_glm(x,alpha,beta,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: normal_id_glm 2 | # key: normal_id_glm 3 | # group: Distributions 4 | # -- 5 | normal_id_glm(${1:x}, ${2:alpha}, ${3:beta}, ${4:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/normal_id_glm_lpdf(y,x,alpha,beta,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: normal_id_glm_lpdf 2 | # key: normal_id_glm_lpdf 3 | # group: Functions 4 | # -- 5 | normal_id_glm_lpdf(${1:y} | ${2:x}, ${3:alpha}, ${4:beta}, ${5:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/normal_lccdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: normal_lccdf 2 | # key: normal_lccdf 3 | # group: Functions 4 | # -- 5 | normal_lccdf(${1:y} | ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/normal_lcdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: normal_lcdf 2 | # key: normal_lcdf 3 | # group: Functions 4 | # -- 5 | normal_lcdf(${1:y} | ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/normal_lpdf(y,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: normal_lpdf 2 | # key: normal_lpdf 3 | # group: Functions 4 | # -- 5 | normal_lpdf(${1:y} | ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/normal_rng(mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: normal_rng 2 | # key: normal_rng 3 | # group: Functions 4 | # -- 5 | normal_rng(${1:mu}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/num_elements(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: num_elements 2 | # key: num_elements 3 | # group: Functions 4 | # -- 5 | num_elements(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/ordered_logistic(eta,c).yasnippet: -------------------------------------------------------------------------------- 1 | # name: ordered_logistic 2 | # key: ordered_logistic 3 | # group: Distributions 4 | # -- 5 | ordered_logistic(${1:eta}, ${2:c})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/ordered_logistic_glm(x,beta,c).yasnippet: -------------------------------------------------------------------------------- 1 | # name: ordered_logistic_glm 2 | # key: ordered_logistic_glm 3 | # group: Distributions 4 | # -- 5 | ordered_logistic_glm(${1:x}, ${2:beta}, ${3:c})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/ordered_logistic_glm_lpmf(y,x,beta,c).yasnippet: -------------------------------------------------------------------------------- 1 | # name: ordered_logistic_glm_lpmf 2 | # key: ordered_logistic_glm_lpmf 3 | # group: Functions 4 | # -- 5 | ordered_logistic_glm_lpmf(${1:y} | ${2:x}, ${3:beta}, ${4:c})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/ordered_logistic_lpmf(k,eta,c).yasnippet: -------------------------------------------------------------------------------- 1 | # name: ordered_logistic_lpmf 2 | # key: ordered_logistic_lpmf 3 | # group: Functions 4 | # -- 5 | ordered_logistic_lpmf(${1:k} | ${2:eta}, ${3:c})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/ordered_logistic_rng(eta,c).yasnippet: -------------------------------------------------------------------------------- 1 | # name: ordered_logistic_rng 2 | # key: ordered_logistic_rng 3 | # group: Functions 4 | # -- 5 | ordered_logistic_rng(${1:eta}, ${2:c})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/ordered_probit(eta,c).yasnippet: -------------------------------------------------------------------------------- 1 | # name: ordered_probit 2 | # key: ordered_probit 3 | # group: Distributions 4 | # -- 5 | ordered_probit(${1:eta}, ${2:c})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/ordered_probit_lpmf(k,eta,c).yasnippet: -------------------------------------------------------------------------------- 1 | # name: ordered_probit_lpmf 2 | # key: ordered_probit_lpmf 3 | # group: Functions 4 | # -- 5 | ordered_probit_lpmf(${1:k} | ${2:eta}, ${3:c})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/ordered_probit_rng(eta,c).yasnippet: -------------------------------------------------------------------------------- 1 | # name: ordered_probit_rng 2 | # key: ordered_probit_rng 3 | # group: Functions 4 | # -- 5 | ordered_probit_rng(${1:eta}, ${2:c})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/owens_t(h,a).yasnippet: -------------------------------------------------------------------------------- 1 | # name: owens_t 2 | # key: owens_t 3 | # group: Functions 4 | # -- 5 | owens_t(${1:h}, ${2:a})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/pareto(y_min,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: pareto 2 | # key: pareto 3 | # group: Distributions 4 | # -- 5 | pareto(${1:y_min}, ${2:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/pareto_cdf(y,y_min,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: pareto_cdf 2 | # key: pareto_cdf 3 | # group: Functions 4 | # -- 5 | pareto_cdf(${1:y}, ${2:y_min}, ${3:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/pareto_lccdf(y,y_min,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: pareto_lccdf 2 | # key: pareto_lccdf 3 | # group: Functions 4 | # -- 5 | pareto_lccdf(${1:y} | ${2:y_min}, ${3:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/pareto_lcdf(y,y_min,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: pareto_lcdf 2 | # key: pareto_lcdf 3 | # group: Functions 4 | # -- 5 | pareto_lcdf(${1:y} | ${2:y_min}, ${3:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/pareto_lpdf(y,y_min,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: pareto_lpdf 2 | # key: pareto_lpdf 3 | # group: Functions 4 | # -- 5 | pareto_lpdf(${1:y} | ${2:y_min}, ${3:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/pareto_rng(y_min,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: pareto_rng 2 | # key: pareto_rng 3 | # group: Functions 4 | # -- 5 | pareto_rng(${1:y_min}, ${2:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/pareto_type_2(mu,lambda,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: pareto_type_2 2 | # key: pareto_type_2 3 | # group: Distributions 4 | # -- 5 | pareto_type_2(${1:mu}, ${2:lambda}, ${3:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/pareto_type_2_cdf(y,mu,lambda,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: pareto_type_2_cdf 2 | # key: pareto_type_2_cdf 3 | # group: Functions 4 | # -- 5 | pareto_type_2_cdf(${1:y}, ${2:mu}, ${3:lambda}, ${4:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/pareto_type_2_lccdf(y,mu,lambda,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: pareto_type_2_lccdf 2 | # key: pareto_type_2_lccdf 3 | # group: Functions 4 | # -- 5 | pareto_type_2_lccdf(${1:y} | ${2:mu}, ${3:lambda}, ${4:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/pareto_type_2_lcdf(y,mu,lambda,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: pareto_type_2_lcdf 2 | # key: pareto_type_2_lcdf 3 | # group: Functions 4 | # -- 5 | pareto_type_2_lcdf(${1:y} | ${2:mu}, ${3:lambda}, ${4:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/pareto_type_2_lpdf(y,mu,lambda,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: pareto_type_2_lpdf 2 | # key: pareto_type_2_lpdf 3 | # group: Functions 4 | # -- 5 | pareto_type_2_lpdf(${1:y} | ${2:mu}, ${3:lambda}, ${4:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/pareto_type_2_rng(mu,lambda,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: pareto_type_2_rng 2 | # key: pareto_type_2_rng 3 | # group: Functions 4 | # -- 5 | pareto_type_2_rng(${1:mu}, ${2:lambda}, ${3:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/poisson(lambda).yasnippet: -------------------------------------------------------------------------------- 1 | # name: poisson 2 | # key: poisson 3 | # group: Distributions 4 | # -- 5 | poisson(${1:lambda})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/poisson_cdf(n,lambda).yasnippet: -------------------------------------------------------------------------------- 1 | # name: poisson_cdf 2 | # key: poisson_cdf 3 | # group: Functions 4 | # -- 5 | poisson_cdf(${1:n}, ${2:lambda})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/poisson_lccdf(n,lambda).yasnippet: -------------------------------------------------------------------------------- 1 | # name: poisson_lccdf 2 | # key: poisson_lccdf 3 | # group: Functions 4 | # -- 5 | poisson_lccdf(${1:n} | ${2:lambda})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/poisson_lcdf(n,lambda).yasnippet: -------------------------------------------------------------------------------- 1 | # name: poisson_lcdf 2 | # key: poisson_lcdf 3 | # group: Functions 4 | # -- 5 | poisson_lcdf(${1:n} | ${2:lambda})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/poisson_log(alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: poisson_log 2 | # key: poisson_log 3 | # group: Distributions 4 | # -- 5 | poisson_log(${1:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/poisson_log_glm(x,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: poisson_log_glm 2 | # key: poisson_log_glm 3 | # group: Distributions 4 | # -- 5 | poisson_log_glm(${1:x}, ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/poisson_log_glm_lpmf(y,x,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: poisson_log_glm_lpmf 2 | # key: poisson_log_glm_lpmf 3 | # group: Functions 4 | # -- 5 | poisson_log_glm_lpmf(${1:y} | ${2:x}, ${3:alpha}, ${4:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/poisson_log_lpmf(n,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: poisson_log_lpmf 2 | # key: poisson_log_lpmf 3 | # group: Functions 4 | # -- 5 | poisson_log_lpmf(${1:n} | ${2:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/poisson_log_rng(alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: poisson_log_rng 2 | # key: poisson_log_rng 3 | # group: Functions 4 | # -- 5 | poisson_log_rng(${1:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/poisson_lpmf(n,lambda).yasnippet: -------------------------------------------------------------------------------- 1 | # name: poisson_lpmf 2 | # key: poisson_lpmf 3 | # group: Functions 4 | # -- 5 | poisson_lpmf(${1:n} | ${2:lambda})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/poisson_rng(lambda).yasnippet: -------------------------------------------------------------------------------- 1 | # name: poisson_rng 2 | # key: poisson_rng 3 | # group: Functions 4 | # -- 5 | poisson_rng(${1:lambda})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/pow(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: pow 2 | # key: pow 3 | # group: Functions 4 | # -- 5 | pow(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/print(x1,...,xN).yasnippet: -------------------------------------------------------------------------------- 1 | # name: print 2 | # key: print 3 | # group: Functions 4 | # -- 5 | print(${1:x1}, ${2:...}, ${3:xN})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/prod(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: prod 2 | # key: prod 3 | # group: Functions 4 | # -- 5 | prod(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/qr_Q(A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: qr_Q 2 | # key: qr_Q 3 | # group: Functions 4 | # -- 5 | qr_Q(${1:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/qr_R(A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: qr_R 2 | # key: qr_R 3 | # group: Functions 4 | # -- 5 | qr_R(${1:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/qr_thin_Q(A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: qr_thin_Q 2 | # key: qr_thin_Q 3 | # group: Functions 4 | # -- 5 | qr_thin_Q(${1:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/qr_thin_R(A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: qr_thin_R 2 | # key: qr_thin_R 3 | # group: Functions 4 | # -- 5 | qr_thin_R(${1:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/quad_form(A,B).yasnippet: -------------------------------------------------------------------------------- 1 | # name: quad_form 2 | # key: quad_form 3 | # group: Functions 4 | # -- 5 | quad_form(${1:A}, ${2:B})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/quad_form_diag(m,rv).yasnippet: -------------------------------------------------------------------------------- 1 | # name: quad_form_diag 2 | # key: quad_form_diag 3 | # group: Functions 4 | # -- 5 | quad_form_diag(${1:m}, ${2:rv})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/quad_form_diag(m,v).yasnippet: -------------------------------------------------------------------------------- 1 | # name: quad_form_diag 2 | # key: quad_form_diag 3 | # group: Functions 4 | # -- 5 | quad_form_diag(${1:m}, ${2:v})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/quad_form_sym(A,B).yasnippet: -------------------------------------------------------------------------------- 1 | # name: quad_form_sym 2 | # key: quad_form_sym 3 | # group: Functions 4 | # -- 5 | quad_form_sym(${1:A}, ${2:B})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rank(v,s).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rank 2 | # key: rank 3 | # group: Functions 4 | # -- 5 | rank(${1:v}, ${2:s})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rayleigh(sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rayleigh 2 | # key: rayleigh 3 | # group: Distributions 4 | # -- 5 | rayleigh(${1:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rayleigh_cdf(y,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rayleigh_cdf 2 | # key: rayleigh_cdf 3 | # group: Functions 4 | # -- 5 | rayleigh_cdf(${1:y}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rayleigh_lccdf(y,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rayleigh_lccdf 2 | # key: rayleigh_lccdf 3 | # group: Functions 4 | # -- 5 | rayleigh_lccdf(${1:y} | ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rayleigh_lcdf(y,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rayleigh_lcdf 2 | # key: rayleigh_lcdf 3 | # group: Functions 4 | # -- 5 | rayleigh_lcdf(${1:y} | ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rayleigh_lpdf(y,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rayleigh_lpdf 2 | # key: rayleigh_lpdf 3 | # group: Functions 4 | # -- 5 | rayleigh_lpdf(${1:y} | ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rayleigh_rng(sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rayleigh_rng 2 | # key: rayleigh_rng 3 | # group: Functions 4 | # -- 5 | rayleigh_rng(${1:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/reduce_sum(f,x,grainsize,s1,s2,...).yasnippet: -------------------------------------------------------------------------------- 1 | # name: reduce_sum 2 | # key: reduce_sum 3 | # group: Functions 4 | # -- 5 | reduce_sum(${1:f}, ${2:x}, ${3:grainsize}, ${4:s1}, ${5:s2}, ${6:...})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/reject(x1,...,xN).yasnippet: -------------------------------------------------------------------------------- 1 | # name: reject 2 | # key: reject 3 | # group: Functions 4 | # -- 5 | reject(${1:x1}, ${2:...}, ${3:xN})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rep_array(x,k,m,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rep_array 2 | # key: rep_array 3 | # group: Functions 4 | # -- 5 | rep_array(${1:x}, ${2:k}, ${3:m}, ${4:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rep_array(x,m,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rep_array 2 | # key: rep_array 3 | # group: Functions 4 | # -- 5 | rep_array(${1:x}, ${2:m}, ${3:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rep_array(x,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rep_array 2 | # key: rep_array 3 | # group: Functions 4 | # -- 5 | rep_array(${1:x}, ${2:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rep_matrix(rv,m).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rep_matrix 2 | # key: rep_matrix 3 | # group: Functions 4 | # -- 5 | rep_matrix(${1:rv}, ${2:m})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rep_matrix(v,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rep_matrix 2 | # key: rep_matrix 3 | # group: Functions 4 | # -- 5 | rep_matrix(${1:v}, ${2:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rep_matrix(x,m,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rep_matrix 2 | # key: rep_matrix 3 | # group: Functions 4 | # -- 5 | rep_matrix(${1:x}, ${2:m}, ${3:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rep_row_vector(x,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rep_row_vector 2 | # key: rep_row_vector 3 | # group: Functions 4 | # -- 5 | rep_row_vector(${1:x}, ${2:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rep_vector(x,m).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rep_vector 2 | # key: rep_vector 3 | # group: Functions 4 | # -- 5 | rep_vector(${1:x}, ${2:m})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/reverse(v).yasnippet: -------------------------------------------------------------------------------- 1 | # name: reverse 2 | # key: reverse 3 | # group: Functions 4 | # -- 5 | reverse(${1:v})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rising_factorial(x,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rising_factorial 2 | # key: rising_factorial 3 | # group: Functions 4 | # -- 5 | rising_factorial(${1:x}, ${2:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/round(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: round 2 | # key: round 3 | # group: Functions 4 | # -- 5 | round(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/row(x,m).yasnippet: -------------------------------------------------------------------------------- 1 | # name: row 2 | # key: row 3 | # group: Functions 4 | # -- 5 | row(${1:x}, ${2:m})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rows(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rows 2 | # key: rows 3 | # group: Functions 4 | # -- 5 | rows(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rows_dot_product(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rows_dot_product 2 | # key: rows_dot_product 3 | # group: Functions 4 | # -- 5 | rows_dot_product(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/rows_dot_self(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: rows_dot_self 2 | # key: rows_dot_self 3 | # group: Functions 4 | # -- 5 | rows_dot_self(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/scale_matrix_exp_multiply(t,A,B).yasnippet: -------------------------------------------------------------------------------- 1 | # name: scale_matrix_exp_multiply 2 | # key: scale_matrix_exp_multiply 3 | # group: Functions 4 | # -- 5 | scale_matrix_exp_multiply(${1:t}, ${2:A}, ${3:B})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/scaled_inv_chi_square(nu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: scaled_inv_chi_square 2 | # key: scaled_inv_chi_square 3 | # group: Distributions 4 | # -- 5 | scaled_inv_chi_square(${1:nu}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/scaled_inv_chi_square_cdf(y,nu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: scaled_inv_chi_square_cdf 2 | # key: scaled_inv_chi_square_cdf 3 | # group: Functions 4 | # -- 5 | scaled_inv_chi_square_cdf(${1:y}, ${2:nu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/scaled_inv_chi_square_lccdf(y,nu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: scaled_inv_chi_square_lccdf 2 | # key: scaled_inv_chi_square_lccdf 3 | # group: Functions 4 | # -- 5 | scaled_inv_chi_square_lccdf(${1:y} | ${2:nu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/scaled_inv_chi_square_lcdf(y,nu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: scaled_inv_chi_square_lcdf 2 | # key: scaled_inv_chi_square_lcdf 3 | # group: Functions 4 | # -- 5 | scaled_inv_chi_square_lcdf(${1:y} | ${2:nu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/scaled_inv_chi_square_lpdf(y,nu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: scaled_inv_chi_square_lpdf 2 | # key: scaled_inv_chi_square_lpdf 3 | # group: Functions 4 | # -- 5 | scaled_inv_chi_square_lpdf(${1:y} | ${2:nu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/scaled_inv_chi_square_rng(nu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: scaled_inv_chi_square_rng 2 | # key: scaled_inv_chi_square_rng 3 | # group: Functions 4 | # -- 5 | scaled_inv_chi_square_rng(${1:nu}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/sd(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: sd 2 | # key: sd 3 | # group: Functions 4 | # -- 5 | sd(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/segment(rv,i,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: segment 2 | # key: segment 3 | # group: Functions 4 | # -- 5 | segment(${1:rv}, ${2:i}, ${3:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/segment(sv,i,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: segment 2 | # key: segment 3 | # group: Functions 4 | # -- 5 | segment(${1:sv}, ${2:i}, ${3:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/segment(v,i,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: segment 2 | # key: segment 3 | # group: Functions 4 | # -- 5 | segment(${1:v}, ${2:i}, ${3:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/sin(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: sin 2 | # key: sin 3 | # group: Functions 4 | # -- 5 | sin(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/singular_values(A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: singular_values 2 | # key: singular_values 3 | # group: Functions 4 | # -- 5 | singular_values(${1:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/sinh(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: sinh 2 | # key: sinh 3 | # group: Functions 4 | # -- 5 | sinh(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/size(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: size 2 | # key: size 3 | # group: Functions 4 | # -- 5 | size(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/skew_normal(xi,omega,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: skew_normal 2 | # key: skew_normal 3 | # group: Distributions 4 | # -- 5 | skew_normal(${1:xi}, ${2:omega}, ${3:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/skew_normal_cdf(y,xi,omega,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: skew_normal_cdf 2 | # key: skew_normal_cdf 3 | # group: Functions 4 | # -- 5 | skew_normal_cdf(${1:y}, ${2:xi}, ${3:omega}, ${4:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/skew_normal_lccdf(y,xi,omega,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: skew_normal_lccdf 2 | # key: skew_normal_lccdf 3 | # group: Functions 4 | # -- 5 | skew_normal_lccdf(${1:y} | ${2:xi}, ${3:omega}, ${4:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/skew_normal_lcdf(y,xi,omega,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: skew_normal_lcdf 2 | # key: skew_normal_lcdf 3 | # group: Functions 4 | # -- 5 | skew_normal_lcdf(${1:y} | ${2:xi}, ${3:omega}, ${4:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/skew_normal_lpdf(y,xi,omega,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: skew_normal_lpdf 2 | # key: skew_normal_lpdf 3 | # group: Functions 4 | # -- 5 | skew_normal_lpdf(${1:y} | ${2:xi}, ${3:omega}, ${4:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/skew_normal_rng(xi,omega,alpha).yasnippet: -------------------------------------------------------------------------------- 1 | # name: skew_normal_rng 2 | # key: skew_normal_rng 3 | # group: Functions 4 | # -- 5 | skew_normal_rng(${1:xi}, ${2:omega}, ${3:alpha})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/softmax(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: softmax 2 | # key: softmax 3 | # group: Functions 4 | # -- 5 | softmax(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/sort_asc(v).yasnippet: -------------------------------------------------------------------------------- 1 | # name: sort_asc 2 | # key: sort_asc 3 | # group: Functions 4 | # -- 5 | sort_asc(${1:v})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/sort_desc(v).yasnippet: -------------------------------------------------------------------------------- 1 | # name: sort_desc 2 | # key: sort_desc 3 | # group: Functions 4 | # -- 5 | sort_desc(${1:v})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/sort_indices_asc(v).yasnippet: -------------------------------------------------------------------------------- 1 | # name: sort_indices_asc 2 | # key: sort_indices_asc 3 | # group: Functions 4 | # -- 5 | sort_indices_asc(${1:v})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/sort_indices_desc(v).yasnippet: -------------------------------------------------------------------------------- 1 | # name: sort_indices_desc 2 | # key: sort_indices_desc 3 | # group: Functions 4 | # -- 5 | sort_indices_desc(${1:v})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/sqrt(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: sqrt 2 | # key: sqrt 3 | # group: Functions 4 | # -- 5 | sqrt(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/square(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: square 2 | # key: square 3 | # group: Functions 4 | # -- 5 | square(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/squared_distance(x,y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: squared_distance 2 | # key: squared_distance 3 | # group: Functions 4 | # -- 5 | squared_distance(${1:x}, ${2:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/std_normal().yasnippet: -------------------------------------------------------------------------------- 1 | # name: std_normal 2 | # key: std_normal 3 | # group: Distributions 4 | # -- 5 | std_normal()$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/std_normal_cdf(y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: std_normal_cdf 2 | # key: std_normal_cdf 3 | # group: Functions 4 | # -- 5 | std_normal_cdf(${1:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/std_normal_lccdf(y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: std_normal_lccdf 2 | # key: std_normal_lccdf 3 | # group: Functions 4 | # -- 5 | std_normal_lccdf(${1:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/std_normal_lcdf(y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: std_normal_lcdf 2 | # key: std_normal_lcdf 3 | # group: Functions 4 | # -- 5 | std_normal_lcdf(${1:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/std_normal_lpdf(y).yasnippet: -------------------------------------------------------------------------------- 1 | # name: std_normal_lpdf 2 | # key: std_normal_lpdf 3 | # group: Functions 4 | # -- 5 | std_normal_lpdf(${1:y})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/std_normal_rng().yasnippet: -------------------------------------------------------------------------------- 1 | # name: std_normal_rng 2 | # key: std_normal_rng 3 | # group: Functions 4 | # -- 5 | std_normal_rng()$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/step(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: step 2 | # key: step 3 | # group: Functions 4 | # -- 5 | step(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/student_t(nu,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: student_t 2 | # key: student_t 3 | # group: Distributions 4 | # -- 5 | student_t(${1:nu}, ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/student_t_cdf(y,nu,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: student_t_cdf 2 | # key: student_t_cdf 3 | # group: Functions 4 | # -- 5 | student_t_cdf(${1:y}, ${2:nu}, ${3:mu}, ${4:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/student_t_lccdf(y,nu,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: student_t_lccdf 2 | # key: student_t_lccdf 3 | # group: Functions 4 | # -- 5 | student_t_lccdf(${1:y} | ${2:nu}, ${3:mu}, ${4:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/student_t_lcdf(y,nu,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: student_t_lcdf 2 | # key: student_t_lcdf 3 | # group: Functions 4 | # -- 5 | student_t_lcdf(${1:y} | ${2:nu}, ${3:mu}, ${4:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/student_t_lpdf(y,nu,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: student_t_lpdf 2 | # key: student_t_lpdf 3 | # group: Functions 4 | # -- 5 | student_t_lpdf(${1:y} | ${2:nu}, ${3:mu}, ${4:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/student_t_rng(nu,mu,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: student_t_rng 2 | # key: student_t_rng 3 | # group: Functions 4 | # -- 5 | student_t_rng(${1:nu}, ${2:mu}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/sub_col(x,i,j,n_rows).yasnippet: -------------------------------------------------------------------------------- 1 | # name: sub_col 2 | # key: sub_col 3 | # group: Functions 4 | # -- 5 | sub_col(${1:x}, ${2:i}, ${3:j}, ${4:n_rows})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/sub_row(x,i,j,n_cols).yasnippet: -------------------------------------------------------------------------------- 1 | # name: sub_row 2 | # key: sub_row 3 | # group: Functions 4 | # -- 5 | sub_row(${1:x}, ${2:i}, ${3:j}, ${4:n_cols})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/sum(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: sum 2 | # key: sum 3 | # group: Functions 4 | # -- 5 | sum(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/tail(rv,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: tail 2 | # key: tail 3 | # group: Functions 4 | # -- 5 | tail(${1:rv}, ${2:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/tail(sv,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: tail 2 | # key: tail 3 | # group: Functions 4 | # -- 5 | tail(${1:sv}, ${2:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/tail(v,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: tail 2 | # key: tail 3 | # group: Functions 4 | # -- 5 | tail(${1:v}, ${2:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/tan(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: tan 2 | # key: tan 3 | # group: Functions 4 | # -- 5 | tan(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/tanh(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: tanh 2 | # key: tanh 3 | # group: Functions 4 | # -- 5 | tanh(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/tcrossprod(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: tcrossprod 2 | # key: tcrossprod 3 | # group: Functions 4 | # -- 5 | tcrossprod(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/tgamma(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: tgamma 2 | # key: tgamma 3 | # group: Functions 4 | # -- 5 | tgamma(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_array_1d(a).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_array_1d 2 | # key: to_array_1d 3 | # group: Functions 4 | # -- 5 | to_array_1d(${1:a})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_array_1d(m).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_array_1d 2 | # key: to_array_1d 3 | # group: Functions 4 | # -- 5 | to_array_1d(${1:m})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_array_1d(v).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_array_1d 2 | # key: to_array_1d 3 | # group: Functions 4 | # -- 5 | to_array_1d(${1:v})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_array_2d(m).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_array_2d 2 | # key: to_array_2d 3 | # group: Functions 4 | # -- 5 | to_array_2d(${1:m})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_matrix(a).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_matrix 2 | # key: to_matrix 3 | # group: Functions 4 | # -- 5 | to_matrix(${1:a})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_matrix(a,m,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_matrix 2 | # key: to_matrix 3 | # group: Functions 4 | # -- 5 | to_matrix(${1:a}, ${2:m}, ${3:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_matrix(a,m,n,col_major).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_matrix 2 | # key: to_matrix 3 | # group: Functions 4 | # -- 5 | to_matrix(${1:a}, ${2:m}, ${3:n}, ${4:col_major})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_matrix(m).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_matrix 2 | # key: to_matrix 3 | # group: Functions 4 | # -- 5 | to_matrix(${1:m})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_matrix(m,m,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_matrix 2 | # key: to_matrix 3 | # group: Functions 4 | # -- 5 | to_matrix(${1:m}, ${2:m}, ${3:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_matrix(m,m,n,col_major).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_matrix 2 | # key: to_matrix 3 | # group: Functions 4 | # -- 5 | to_matrix(${1:m}, ${2:m}, ${3:n}, ${4:col_major})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_matrix(v).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_matrix 2 | # key: to_matrix 3 | # group: Functions 4 | # -- 5 | to_matrix(${1:v})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_matrix(v,m,n).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_matrix 2 | # key: to_matrix 3 | # group: Functions 4 | # -- 5 | to_matrix(${1:v}, ${2:m}, ${3:n})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_matrix(v,m,n,col_major).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_matrix 2 | # key: to_matrix 3 | # group: Functions 4 | # -- 5 | to_matrix(${1:v}, ${2:m}, ${3:n}, ${4:col_major})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_row_vector(a).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_row_vector 2 | # key: to_row_vector 3 | # group: Functions 4 | # -- 5 | to_row_vector(${1:a})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_row_vector(m).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_row_vector 2 | # key: to_row_vector 3 | # group: Functions 4 | # -- 5 | to_row_vector(${1:m})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_row_vector(v).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_row_vector 2 | # key: to_row_vector 3 | # group: Functions 4 | # -- 5 | to_row_vector(${1:v})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_vector(a).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_vector 2 | # key: to_vector 3 | # group: Functions 4 | # -- 5 | to_vector(${1:a})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_vector(m).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_vector 2 | # key: to_vector 3 | # group: Functions 4 | # -- 5 | to_vector(${1:m})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/to_vector(v).yasnippet: -------------------------------------------------------------------------------- 1 | # name: to_vector 2 | # key: to_vector 3 | # group: Functions 4 | # -- 5 | to_vector(${1:v})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/trace(A).yasnippet: -------------------------------------------------------------------------------- 1 | # name: trace 2 | # key: trace 3 | # group: Functions 4 | # -- 5 | trace(${1:A})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/trace_gen_quad_form(D,A,B).yasnippet: -------------------------------------------------------------------------------- 1 | # name: trace_gen_quad_form 2 | # key: trace_gen_quad_form 3 | # group: Functions 4 | # -- 5 | trace_gen_quad_form(${1:D}, ${2:A}, ${3:B})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/trace_quad_form(A,B).yasnippet: -------------------------------------------------------------------------------- 1 | # name: trace_quad_form 2 | # key: trace_quad_form 3 | # group: Functions 4 | # -- 5 | trace_quad_form(${1:A}, ${2:B})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/trigamma(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: trigamma 2 | # key: trigamma 3 | # group: Functions 4 | # -- 5 | trigamma(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/trunc(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: trunc 2 | # key: trunc 3 | # group: Functions 4 | # -- 5 | trunc(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/uniform(alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: uniform 2 | # key: uniform 3 | # group: Distributions 4 | # -- 5 | uniform(${1:alpha}, ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/uniform_cdf(y,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: uniform_cdf 2 | # key: uniform_cdf 3 | # group: Functions 4 | # -- 5 | uniform_cdf(${1:y}, ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/uniform_lccdf(y,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: uniform_lccdf 2 | # key: uniform_lccdf 3 | # group: Functions 4 | # -- 5 | uniform_lccdf(${1:y} | ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/uniform_lcdf(y,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: uniform_lcdf 2 | # key: uniform_lcdf 3 | # group: Functions 4 | # -- 5 | uniform_lcdf(${1:y} | ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/uniform_lpdf(y,alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: uniform_lpdf 2 | # key: uniform_lpdf 3 | # group: Functions 4 | # -- 5 | uniform_lpdf(${1:y} | ${2:alpha}, ${3:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/uniform_rng(alpha,beta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: uniform_rng 2 | # key: uniform_rng 3 | # group: Functions 4 | # -- 5 | uniform_rng(${1:alpha}, ${2:beta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/variance(x).yasnippet: -------------------------------------------------------------------------------- 1 | # name: variance 2 | # key: variance 3 | # group: Functions 4 | # -- 5 | variance(${1:x})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/von_mises(mu,kappa).yasnippet: -------------------------------------------------------------------------------- 1 | # name: von_mises 2 | # key: von_mises 3 | # group: Distributions 4 | # -- 5 | von_mises(${1:mu}, ${2:kappa})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/von_mises_lpdf(y,mu,kappa).yasnippet: -------------------------------------------------------------------------------- 1 | # name: von_mises_lpdf 2 | # key: von_mises_lpdf 3 | # group: Functions 4 | # -- 5 | von_mises_lpdf(${1:y} | ${2:mu}, ${3:kappa})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/von_mises_rng(mu,kappa).yasnippet: -------------------------------------------------------------------------------- 1 | # name: von_mises_rng 2 | # key: von_mises_rng 3 | # group: Functions 4 | # -- 5 | von_mises_rng(${1:mu}, ${2:kappa})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/weibull(alpha,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: weibull 2 | # key: weibull 3 | # group: Distributions 4 | # -- 5 | weibull(${1:alpha}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/weibull_cdf(y,alpha,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: weibull_cdf 2 | # key: weibull_cdf 3 | # group: Functions 4 | # -- 5 | weibull_cdf(${1:y}, ${2:alpha}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/weibull_lccdf(y,alpha,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: weibull_lccdf 2 | # key: weibull_lccdf 3 | # group: Functions 4 | # -- 5 | weibull_lccdf(${1:y} | ${2:alpha}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/weibull_lcdf(y,alpha,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: weibull_lcdf 2 | # key: weibull_lcdf 3 | # group: Functions 4 | # -- 5 | weibull_lcdf(${1:y} | ${2:alpha}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/weibull_lpdf(y,alpha,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: weibull_lpdf 2 | # key: weibull_lpdf 3 | # group: Functions 4 | # -- 5 | weibull_lpdf(${1:y} | ${2:alpha}, ${3:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/weibull_rng(alpha,sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: weibull_rng 2 | # key: weibull_rng 3 | # group: Functions 4 | # -- 5 | weibull_rng(${1:alpha}, ${2:sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/wiener(alpha,tau,beta,delta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: wiener 2 | # key: wiener 3 | # group: Distributions 4 | # -- 5 | wiener(${1:alpha}, ${2:tau}, ${3:beta}, ${4:delta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/wiener_lpdf(y,alpha,tau,beta,delta).yasnippet: -------------------------------------------------------------------------------- 1 | # name: wiener_lpdf 2 | # key: wiener_lpdf 3 | # group: Functions 4 | # -- 5 | wiener_lpdf(${1:y} | ${2:alpha}, ${3:tau}, ${4:beta}, ${5:delta})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/wishart(nu,Sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: wishart 2 | # key: wishart 3 | # group: Distributions 4 | # -- 5 | wishart(${1:nu}, ${2:Sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/wishart_lpdf(W,nu,Sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: wishart_lpdf 2 | # key: wishart_lpdf 3 | # group: Functions 4 | # -- 5 | wishart_lpdf(${1:W} | ${2:nu}, ${3:Sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/functions/wishart_rng(nu,Sigma).yasnippet: -------------------------------------------------------------------------------- 1 | # name: wishart_rng 2 | # key: wishart_rng 3 | # group: Functions 4 | # -- 5 | wishart_rng(${1:nu}, ${2:Sigma})$0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/generated_quantities.yasnippet: -------------------------------------------------------------------------------- 1 | # name: generated quantities {...} 2 | # key: generated 3 | # group: Blocks 4 | # -- 5 | generated quantities { 6 | $0 7 | } 8 | -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/if.yasnippet: -------------------------------------------------------------------------------- 1 | # name: if (...) { ... } 2 | # key: if 3 | # group: Structure 4 | # -- 5 | if (${1:condition}) { 6 | $0 7 | } -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/int.yasnippet: -------------------------------------------------------------------------------- 1 | # name: int ... ; 2 | # key: int 3 | # group: Types 4 | # -- 5 | int${1:<${2:lower=...,upper=...}>} ${3:variable}${4:[${5:dims}]}; 6 | $0 7 | -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/integrate_ode_bdf.yasnippet: -------------------------------------------------------------------------------- 1 | # name: integrate_ode_bdf(...); 2 | # key: integrate_ode_bdf 3 | # -- 4 | integrate_ode_bdf(${1:function}, ${2:y0}, ${3:t0},${4:t}, ${5:theta}, ${6:x_r}, ${7:x_i}${8:${9:real_tol}, ${10:abs_tol}, ${11:max_num_steps}}); 5 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/integrate_ode_rk45.yasnippet: -------------------------------------------------------------------------------- 1 | # name: integrate_ode_rk45(...); 2 | # key: integrate_ode_rk45 3 | # -- 4 | integrate_ode_rk45(${1:function}, ${2:y0}, ${3:t0},${4:t}, ${5:theta}, ${6:x_r}, ${7:x_i}${8:${9:real_tol}, ${10:abs_tol}, ${11:max_num_steps}}); 5 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/lower.yasnippet: -------------------------------------------------------------------------------- 1 | # name: 2 | # key: < 3 | # group: Range Constraints 4 | # -- 5 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/lower_upper.yasnippet: -------------------------------------------------------------------------------- 1 | # name: 2 | # key: < 3 | # group: Range Constraints 4 | # -- 5 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/matrix.yasnippet: -------------------------------------------------------------------------------- 1 | # name: matrix[] ...; 2 | # key: matrix 3 | # group: Types 4 | # -- 5 | matrix${1:<${2:lower=...,upper=...}>}[$3, $4] ${5:variable}${6:[${7:dims}]}; 6 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/model.yasnippet: -------------------------------------------------------------------------------- 1 | # name: model {...} 2 | # key: model 3 | # group: Blocks 4 | # -- 5 | model { 6 | $0 7 | } 8 | -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/ordered.yasnippet: -------------------------------------------------------------------------------- 1 | # name: ordered[] ...; 2 | # key: ordered 3 | # group: Types 4 | # -- 5 | ordered[${1:dim}] ${2:variable}${3:[${4:dims}]}; 6 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/parameters.yasnippet: -------------------------------------------------------------------------------- 1 | # name: parameters {...} 2 | # key: param 3 | # group: Blocks 4 | # -- 5 | parameters { 6 | $0 7 | } 8 | -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/positive_ordered.yasnippet: -------------------------------------------------------------------------------- 1 | # name: positive_ordered[] ...; 2 | # key: pordered 3 | # group: Types 4 | # -- 5 | positive_ordered[${1:dim}] ${2:variable}${3:[${4:dims}]}; 6 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/print.yasnippet: -------------------------------------------------------------------------------- 1 | # name: print(...) 2 | # key: print 3 | # -- 4 | print($1); 5 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/program.yasnippet: -------------------------------------------------------------------------------- 1 | # name: data {...} ... 2 | # key: C-c C-t 3 | # group: Blocks 4 | # -- 5 | data { 6 | $0 7 | } 8 | transformed data { 9 | } 10 | parameters { 11 | } 12 | transformed parameters { 13 | } 14 | model { 15 | } 16 | generated quantities { 17 | } -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/real.yasnippet: -------------------------------------------------------------------------------- 1 | # name: real ...; 2 | # key: real 3 | # group: Types 4 | # -- 5 | real${1:<${2:lower=...,upper=...}>} ${3:variable}${4:[${5:dims}]}; 6 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/reject.yasnippet: -------------------------------------------------------------------------------- 1 | # name: reject(...) 2 | # key: reject 3 | # -- 4 | reject($1); 5 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/row_vector.yasnippet: -------------------------------------------------------------------------------- 1 | # name: row_vector[] ...; 2 | # key: rvector 3 | # group: Types 4 | # -- 5 | row_vector${1:<${2:lower=...,upper=...}>}[${3:expression}] ${4:variable}${5:[${6:dims}]}; 6 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/simplex.yasnippet: -------------------------------------------------------------------------------- 1 | # name: simplex 2 | # key: simplex 3 | # group: Types 4 | # -- 5 | simplex[${1:dim}] ${2:variable}${3:[${4:dims}]}; 6 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/target.yasnippet: -------------------------------------------------------------------------------- 1 | # name: target += ... 2 | # key: target 3 | # -- 4 | target += $0; 5 | -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/transformed_data.yasnippet: -------------------------------------------------------------------------------- 1 | # name: transformed data {...} 2 | # key: tdata 3 | # group: Blocks 4 | # -- 5 | transformed data { 6 | $0 7 | } 8 | -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/transformed_parameters.yasnippet: -------------------------------------------------------------------------------- 1 | # name: transformed parameters{...} 2 | # key: tparam 3 | # group: Blocks 4 | # -- 5 | transformed parameters { 6 | $0 7 | } 8 | -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/unit_vector.yasnippet: -------------------------------------------------------------------------------- 1 | # name: unit_vector[] ...; 2 | # key: uvector 3 | # group: Types 4 | # -- 5 | unit_vector[${1:expression}] ${2:variable}${3:[${4:dims}]}; 6 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/upper.yasnippet: -------------------------------------------------------------------------------- 1 | # name: 2 | # key: < 3 | # group: Range Constraints 4 | # -- 5 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/vector.yasnippet: -------------------------------------------------------------------------------- 1 | # name: vector[] ...; 2 | # key: vector 3 | # group: Types 4 | # -- 5 | vector${1:<${2:lower=...,upper=...}>}[${3:expression}] ${4:variable}${5:[${6:dims}]}; 6 | $0 -------------------------------------------------------------------------------- /stan-snippets/snippets/stan-mode/while.yasnippet: -------------------------------------------------------------------------------- 1 | # name: while (...) { ... } 2 | # key: while 3 | # group: Structure 4 | # -- 5 | while (${1:condition}) { 6 | $0 7 | } --------------------------------------------------------------------------------