├── .git-blame-ignore-revs ├── .gitattributes ├── .github ├── FUNDING.yml ├── ISSUE_TEMPLATE │ ├── bug-report.md │ ├── config.yml │ ├── feature-request.md │ └── todo.md ├── codecov.yml ├── pull_request_template.md └── workflows │ └── binaries.yml ├── .gitignore ├── .ocamlformat ├── Jenkinsfile ├── Jenkinsfile-test-binaries ├── LICENSE.txt ├── Makefile ├── README.md ├── RELEASE-NOTES.txt ├── docs ├── core_ideas.mld ├── cpp_ir.mld ├── dependencies.mld ├── dune ├── exposing_new_functions.mld ├── getting_started.mld ├── img │ ├── architecture.png │ └── information-flow.png ├── index.mld ├── notes │ ├── cpp-expression-generation.txt │ ├── cpp-statement-generation.txt │ ├── stancon_models.tests │ └── tested-optimizations.txt └── parser_messages.mld ├── dune ├── dune-project ├── scripts ├── docker │ ├── ci │ │ └── Dockerfile │ └── static-builder │ │ └── Dockerfile ├── hooks │ ├── install_hooks.sh │ └── pre-commit ├── install_build_deps.sh ├── install_build_deps_windows.sh ├── install_dev_deps.sh ├── install_js_deps.sh ├── install_ocaml.sh ├── install_opam.sh ├── nix_old │ ├── README.md │ ├── default.nix │ └── shell.nix └── setup_dev_env.sh ├── src ├── analysis_and_optimization │ ├── Dataflow_types.ml │ ├── Dataflow_utils.ml │ ├── Dataflow_utils.mli │ ├── Debug_data_generation.ml │ ├── Debug_data_generation.mli │ ├── Dependence_analysis.ml │ ├── Dependence_analysis.mli │ ├── Factor_graph.ml │ ├── Memory_patterns.ml │ ├── Mir_utils.ml │ ├── Mir_utils.mli │ ├── Monotone_framework.ml │ ├── Monotone_framework_sigs.mli │ ├── Optimize.ml │ ├── Optimize.mli │ ├── Partial_evaluator.ml │ ├── Pedantic_analysis.ml │ ├── Pedantic_analysis.mli │ ├── Pedantic_dist_warnings.ml │ ├── dune │ └── phase-ordering-notes.org ├── common │ ├── Gensym.ml │ ├── Gensym.mli │ ├── ICE.ml │ ├── Let_syntax.ml │ ├── Nonempty_list.ml │ ├── Nonempty_list.mli │ └── dune ├── driver │ ├── Entry.ml │ ├── Entry.mli │ ├── Flags.ml │ ├── Flags.mli │ └── dune ├── frontend │ ├── Ast.ml │ ├── Ast_to_Mir.ml │ ├── Ast_to_Mir.mli │ ├── Canonicalize.ml │ ├── Canonicalize.mli │ ├── Debugging.ml │ ├── Deprecation_analysis.ml │ ├── Deprecation_analysis.mli │ ├── Environment.ml │ ├── Environment.mli │ ├── Errors.ml │ ├── Errors.mli │ ├── Include_files.ml │ ├── Info.ml │ ├── Info.mli │ ├── Input_warnings.ml │ ├── Input_warnings.mli │ ├── Parse.ml │ ├── Parse.mli │ ├── Preprocessor.ml │ ├── Preprocessor.mli │ ├── Pretty_print_prog.ml │ ├── Pretty_print_prog.mli │ ├── Pretty_printing.ml │ ├── Promotion.ml │ ├── Semantic_error.ml │ ├── Semantic_error.mli │ ├── SignatureMismatch.ml │ ├── SignatureMismatch.mli │ ├── Syntax_error.ml │ ├── Syntax_error.mli │ ├── Typechecker.ml │ ├── Typechecker.mli │ ├── Warnings.ml │ ├── Warnings.mli │ ├── dune │ ├── lexer.mll │ ├── parser.messages │ ├── parser.mly │ ├── parser_messages_add_type.ml │ └── parser_strip_redundant_state.ml ├── middle │ ├── Expr.ml │ ├── Expr.mli │ ├── Flag_vars.ml │ ├── Fun_kind.ml │ ├── Index.ml │ ├── Internal_fun.ml │ ├── Location.ml │ ├── Location.mli │ ├── Location_span.ml │ ├── Location_span.mli │ ├── Mem_pattern.ml │ ├── Operator.ml │ ├── Program.ml │ ├── SizedType.ml │ ├── Stmt.ml │ ├── Stmt.mli │ ├── Transformation.ml │ ├── Type.ml │ ├── UnsizedType.ml │ ├── Utils.ml │ └── dune ├── stan_math_backend │ ├── Cpp.ml │ ├── Cpp_Json.ml │ ├── Cpp_Json.mli │ ├── Cpp_str.ml │ ├── Cpp_str.mli │ ├── Lower_expr.ml │ ├── Lower_functions.ml │ ├── Lower_functions.mli │ ├── Lower_program.ml │ ├── Lower_program.mli │ ├── Lower_stmt.ml │ ├── Mangle.ml │ ├── Mangle.mli │ ├── Numbering.ml │ ├── Numbering.mli │ ├── Transform_Mir.ml │ ├── Transform_Mir.mli │ └── dune ├── stan_math_signatures │ ├── Generate.ml │ ├── Generated_signatures.mli │ ├── Stan_math_signatures.ml │ ├── Stan_math_signatures.mli │ └── dune ├── stanc │ ├── CLI.ml │ ├── dune │ └── stanc.ml └── stancjs │ ├── dune │ └── stancjs.ml ├── stanc.opam └── test ├── integration ├── bad │ ├── algebra_solver │ │ ├── bad_data_qualifer.stan │ │ ├── bad_fun_type.stan │ │ ├── bad_fun_type_control.stan │ │ ├── bad_newton_fun_type_control.stan │ │ ├── bad_newton_x_i_type.stan │ │ ├── bad_newton_x_i_type_control.stan │ │ ├── bad_newton_x_r_var_type.stan │ │ ├── bad_newton_x_r_var_type_control.stan │ │ ├── bad_newton_y_type.stan │ │ ├── bad_newton_y_type_control.stan │ │ ├── bad_solve_newton_arguments_number.stan │ │ ├── bad_solve_newton_arguments_type.stan │ │ ├── bad_solve_newton_lpdf.stan │ │ ├── bad_solve_newton_lpmf.stan │ │ ├── bad_solve_newton_tol_arguments_number.stan │ │ ├── bad_solve_newton_tol_arguments_type.stan │ │ ├── bad_solve_powell_arguments_number.stan │ │ ├── bad_solve_powell_arguments_type.stan │ │ ├── bad_solve_powell_tol_arguments_number.stan │ │ ├── bad_solve_powell_tol_arguments_type.stan │ │ ├── bad_theta_type.stan │ │ ├── bad_theta_type_control.stan │ │ ├── bad_x_i_type.stan │ │ ├── bad_x_i_type_control.stan │ │ ├── bad_x_r_var_type.stan │ │ ├── bad_x_r_var_type_control.stan │ │ ├── bad_y_type.stan │ │ ├── bad_y_type_control.stan │ │ ├── dune │ │ └── stanc.expected │ ├── array-expr-decl-bad1.stan │ ├── array-expr-decl-bad2.stan │ ├── array-expr-decl-bad3.stan │ ├── array-read-write-assign.stan │ ├── array_expr_bad1.stan │ ├── array_expr_bad2.stan │ ├── assigment-to-function-stanmath.stan │ ├── assign_invalid_lhs1.stan │ ├── assign_invalid_lhs2.stan │ ├── assign_real_to_int.stan │ ├── assignment-to-function.stan │ ├── bad_fundef_returntypes1.stan │ ├── bad_fundef_returntypes2.stan │ ├── bad_fundef_returntypes3.stan │ ├── bad_fundef_returntypes4.stan │ ├── bad_prob_fun_suffix.stan │ ├── bad_to_int1.stan │ ├── bad_to_int2.stan │ ├── bad_var_assignment_type1.stan │ ├── bad_var_assignment_type2.stan │ ├── bad_var_assignment_vec_arr.stan │ ├── bad_while.stan │ ├── binomial_coefficient_sample.stan │ ├── break1.stan │ ├── break2.stan │ ├── break3.stan │ ├── break4.stan │ ├── break5.stan │ ├── break6.stan │ ├── break7.stan │ ├── break8.stan │ ├── call_dist_no_suffix.stan │ ├── ccdf-sample.stan │ ├── cdf-sample.stan │ ├── complex-numbers │ │ ├── assignment-wrong-way.stan │ │ ├── bad_bounds1.stan │ │ ├── bad_bounds2.stan │ │ ├── bad_bounds3.stan │ │ ├── bad_bounds4.stan │ │ ├── dune │ │ └── stanc.expected │ ├── complex_mat_bad.stan │ ├── compound-assign │ │ ├── dune │ │ ├── elt_divide_equals_prim.stan │ │ ├── elt_times_equals_prim.stan │ │ ├── plus_equals_bad_init.stan │ │ ├── plus_equals_bad_lhs_idxs.stan │ │ ├── plus_equals_bad_var_lhs.stan │ │ ├── plus_equals_bad_var_lhs2.stan │ │ ├── plus_equals_bad_var_rhs.stan │ │ ├── plus_equals_matrix_array.stan │ │ ├── plus_equals_matrix_array2.stan │ │ ├── plus_equals_matrix_shape_mismatch.stan │ │ ├── plus_equals_prim_array.stan │ │ ├── plus_equals_row_vec_array.stan │ │ ├── plus_equals_sliced.stan │ │ ├── plus_equals_type_mismatch.stan │ │ ├── plus_equals_type_mismatch2.stan │ │ ├── plus_equals_vector_array.stan │ │ ├── stanc.expected │ │ └── times_equals_matrix_array.stan │ ├── conditional_condition_bad_1.stan │ ├── conditional_condition_bad_2.stan │ ├── continue1.stan │ ├── continue2.stan │ ├── continue3.stan │ ├── continue4.stan │ ├── continue5.stan │ ├── data_index │ │ ├── dune │ │ ├── non_data_index1.stan │ │ ├── non_data_index10.stan │ │ ├── non_data_index11.stan │ │ ├── non_data_index12.stan │ │ ├── non_data_index13.stan │ │ ├── non_data_index14.stan │ │ ├── non_data_index2.stan │ │ ├── non_data_index3.stan │ │ ├── non_data_index4.stan │ │ ├── non_data_index5.stan │ │ ├── non_data_index6.stan │ │ ├── non_data_index7.stan │ │ ├── non_data_index8.stan │ │ ├── non_data_index9.stan │ │ ├── rng_index1.stan │ │ └── stanc.expected │ ├── decl-mutual-inits.stan │ ├── decl-reuse-name.stan │ ├── declare-define-param-block.stan │ ├── declare-define-var-double-1.stan │ ├── declare-define-var-double-2.stan │ ├── declare-define-var-double-3.stan │ ├── declare-define-var-double-4.stan │ ├── declare-define-var-int-1.stan │ ├── declare-define-var-int-2.stan │ ├── declare-define-var-int-3.stan │ ├── declare-define-var-int-4.stan │ ├── declare-define-var-matrix-1.stan │ ├── declare-define-var-vec-1.stan │ ├── dune │ ├── embedded_laplace │ │ ├── autodiff_incompatibility1.stan │ │ ├── autodiff_incompatibility2.stan │ │ ├── autodiff_incompatibility3.stan │ │ ├── autodiff_incompatibility4.stan │ │ ├── autodiff_incompatibility5.stan │ │ ├── bad_callback1.stan │ │ ├── bad_callback2.stan │ │ ├── bad_callback3.stan │ │ ├── bad_callback4.stan │ │ ├── bad_callback5.stan │ │ ├── bad_forward1.stan │ │ ├── bad_forward2.stan │ │ ├── bad_forward3.stan │ │ ├── bad_forward4.stan │ │ ├── bad_forward5.stan │ │ ├── bad_forward6.stan │ │ ├── bad_forward7.stan │ │ ├── bad_forward8.stan │ │ ├── bad_forward9.stan │ │ ├── bad_overload.stan │ │ ├── bad_theta0.stan │ │ ├── bad_tol1.stan │ │ ├── bad_tol2.stan │ │ ├── bad_tol3.stan │ │ ├── bad_tol4.stan │ │ ├── bad_tol5.stan │ │ ├── bad_tol6.stan │ │ ├── bad_tol7.stan │ │ ├── bad_tol8.stan │ │ ├── bad_tol9.stan │ │ ├── dune │ │ ├── missing_args1.stan │ │ ├── missing_args2.stan │ │ ├── missing_args3.stan │ │ ├── missing_args4.stan │ │ ├── missing_args5.stan │ │ ├── missing_args6.stan │ │ ├── missing_args7.stan │ │ ├── missing_args8.stan │ │ ├── missing_args9.stan │ │ └── stanc.expected │ ├── err-bare-type-close-square.stan │ ├── err-close-block.stan │ ├── err-close-function-args.stan │ ├── err-decl-double-params.stan │ ├── err-decl-double.stan │ ├── err-decl-matrix-2.stan │ ├── err-decl-matrix.stan │ ├── err-decl-no-expression.stan │ ├── err-decl-vector-2.stan │ ├── err-decl-vector.stan │ ├── err-double-dims.stan │ ├── err-expected-bracket.stan │ ├── err-expected-end-of-model.stan │ ├── err-expected-generated.stan │ ├── err-expected-model.stan │ ├── err-fun-bare-types-int.stan │ ├── err-if-else-double-else.stan │ ├── err-if-else-no-cond.stan │ ├── err-if-else.stan │ ├── err-integrate-ode-comma.stan │ ├── err-jacobian-plusequals-functor.stan │ ├── err-jacobian-plusequals-scope.stan │ ├── err-jacobian-plusequals-scope2.stan │ ├── err-jacobian-plusequals-scope3.stan │ ├── err-jacobian-plusequals-scope4.stan │ ├── err-jacobian-plusequals-scope5.stan │ ├── err-minus-types.stan │ ├── err-nested-parens-close.stan │ ├── err-nested-parens.stan │ ├── err-no-cond-else-if.stan │ ├── err-no-cond.stan │ ├── err-no-statement.stan │ ├── err-non-int-dims.stan │ ├── err-open-block.stan │ ├── err-second-operand-plus.stan │ ├── err-target-plusequals-scope.stan │ ├── err-transformed-params.stan │ ├── err_void_rng_check.stan │ ├── expect_statement_seq_close_brace.stan │ ├── expect_statement_seq_close_brace_2.stan │ ├── expect_statement_seq_close_brace_3.stan │ ├── expect_statement_seq_close_brace_4.stan │ ├── experiment.stan │ ├── for_loops │ │ ├── assign_to_loop_var1.stan │ │ ├── assign_to_loop_var2.stan │ │ ├── assign_to_loop_var3.stan │ │ ├── assign_to_loop_var4.stan │ │ ├── assign_to_loop_var5.stan │ │ ├── assign_to_loop_var6.stan │ │ ├── assign_to_loop_var7.stan │ │ ├── dune │ │ ├── for_statements_bad_indices0.stan │ │ ├── for_statements_bad_indices1.stan │ │ ├── for_statements_bad_indices2.stan │ │ ├── for_statements_bad_indices3.stan │ │ ├── for_statements_bad_indices4.stan │ │ ├── name_in_use.stan │ │ ├── name_in_use_foreach.stan │ │ ├── reserved.stan │ │ ├── reserved_foreach.stan │ │ └── stanc.expected │ ├── fun-return-typ3.stan │ ├── fun-return-type1.stan │ ├── fun-return-type2.stan │ ├── function-signatures │ │ ├── dune │ │ ├── duplicate-args.stan │ │ ├── falling_factorial.stan │ │ ├── overloading │ │ │ ├── dune │ │ │ ├── invalid_lpmf.stan │ │ │ ├── no_minimum_dae.stan │ │ │ ├── no_minimum_promotion.stan │ │ │ ├── no_minimum_promotion2.stan │ │ │ ├── no_minimum_promotion3.stan │ │ │ ├── no_minimum_reduce_sum.stan │ │ │ ├── no_minimum_tilde.stan │ │ │ ├── no_minimum_tilde2.stan │ │ │ ├── no_minimum_variadic.stan │ │ │ ├── overload_reduce_sum.stan │ │ │ ├── redefine-ccdf-same.stan │ │ │ ├── redefine-ccdf-same2.stan │ │ │ ├── redefine-cdf-same.stan │ │ │ ├── redefine-cdf-same2.stan │ │ │ ├── redefine-prob-same.stan │ │ │ ├── redefinition.stan │ │ │ ├── returntype_issues.stan │ │ │ └── stanc.expected │ │ ├── rising_factorial.stan │ │ └── stanc.expected │ ├── functions-bad0.stan │ ├── functions-bad1.stan │ ├── functions-bad11.stan │ ├── functions-bad12.stan │ ├── functions-bad13.stan │ ├── functions-bad14.stan │ ├── functions-bad15.stan │ ├── functions-bad16.stan │ ├── functions-bad17-void.stan │ ├── functions-bad17.stan │ ├── functions-bad18.stan │ ├── functions-bad19.stan │ ├── functions-bad2.stan │ ├── functions-bad20.stan │ ├── functions-bad21.stan │ ├── functions-bad22-ode.stan │ ├── functions-bad23.stan │ ├── functions-bad24.stan │ ├── functions-bad25.stan │ ├── functions-bad26.stan │ ├── functions-bad27.stan │ ├── functions-bad28.stan │ ├── functions-bad29.stan │ ├── functions-bad3.stan │ ├── functions-bad30.stan │ ├── functions-bad31.stan │ ├── functions-bad32.stan │ ├── functions-bad4.stan │ ├── functions-bad5.stan │ ├── functions-bad6.stan │ ├── functions-bad7.stan │ ├── functions-bad8.stan │ ├── functions-bad9.stan │ ├── get-lp-target-data.stan │ ├── get_lp_bad_scope1.stan │ ├── get_lp_bad_scope2.stan │ ├── hmm_hidden_state_prob │ │ ├── bad_gamma_var.stan │ │ ├── bad_log_omega_var.stan │ │ ├── bad_rho_var.stan │ │ ├── dune │ │ └── stanc.expected │ ├── jacobian_pe_bad.stan │ ├── lang │ │ ├── bad1.stan │ │ ├── bad1.stanfunctions │ │ ├── bad10.stan │ │ ├── bad11.stan │ │ ├── bad12.stan │ │ ├── bad2.stan │ │ ├── bad2.stanfunctions │ │ ├── bad3.stan │ │ ├── bad3.stanfunctions │ │ ├── bad4.stan │ │ ├── bad5.stan │ │ ├── bad6.stan │ │ ├── bad7.stan │ │ ├── bad8.stan │ │ ├── bad9.stan │ │ ├── bad_bar.stan │ │ ├── bad_bounds1.stan │ │ ├── bad_decl1.stan │ │ ├── bad_decl2.stan │ │ ├── bad_decl3.stan │ │ ├── bad_decl4.stan │ │ ├── bad_function.stan │ │ ├── bad_function2.stan │ │ ├── bad_lmpf.stan │ │ ├── bad_lpdf.stan │ │ ├── bad_periods_data.stan │ │ ├── bad_periods_gqs.stan │ │ ├── bad_periods_local.stan │ │ ├── bad_periods_params.stan │ │ ├── bad_periods_tdata.stan │ │ ├── bad_periods_tparams.stan │ │ ├── bad_promotion1.stan │ │ ├── bad_promotions2.stan │ │ ├── bad_promotions3.stan │ │ ├── bad_promotions4.stan │ │ ├── dune │ │ ├── good_all.stan │ │ ├── incomplete.stan │ │ ├── incomplete2.stan │ │ ├── incomplete3.stan │ │ ├── incomplete4.stan │ │ ├── incomplete5.stan │ │ ├── incomplete6.stan │ │ ├── reused_name.stan │ │ ├── stanc.expected │ │ ├── tparam_array_int.stan │ │ ├── tparam_tuple_int.stan │ │ └── unterminated_comment.stan │ ├── local_var_constraint.stan │ ├── local_var_constraint2.stan │ ├── local_var_constraint3.stan │ ├── local_var_constraint4.stan │ ├── log_suffix_bad1.stan │ ├── log_suffix_bad2.stan │ ├── lp-error.stan │ ├── lvalue_indexes1.stan │ ├── lvalue_indexes2.stan │ ├── map_rect │ │ ├── bad_data_i_type.stan │ │ ├── bad_data_int_const.stan │ │ ├── bad_data_r_type.stan │ │ ├── bad_data_real_const.stan │ │ ├── bad_fun_type.stan │ │ ├── bad_job_params_type.stan │ │ ├── bad_lp_fn.stan │ │ ├── bad_not_enough_args.stan │ │ ├── bad_rng_fn.stan │ │ ├── bad_shared_params_type.stan │ │ ├── dune │ │ └── stanc.expected │ ├── matrix_expr_bad1.stan │ ├── matrix_expr_bad2.stan │ ├── matrix_expr_bad3.stan │ ├── matrix_expr_bad4.stan │ ├── missing-pmf.stan │ ├── missing_dist_suffix │ │ ├── completely_undefined1.stan │ │ ├── completely_undefined2.stan │ │ ├── dune │ │ ├── lpmf_lpdf_replacement1.stan │ │ ├── lpmf_lpdf_replacement2.stan │ │ ├── lpmf_lpdf_replacement3.stan │ │ ├── no_rng_suffix.stan │ │ ├── non_existing_distribution_suffix1.stan │ │ ├── non_existing_distribution_suffix2.stan │ │ ├── non_existing_distribution_suffix3.stan │ │ ├── non_existing_distribution_suffix4.stan │ │ ├── removed_suffix.stan │ │ ├── stanc.expected │ │ ├── user_defined.stan │ │ ├── user_defined_no_cdf.stan │ │ ├── user_defined_no_rng.stan │ │ └── user_defined_unnormalized.stan │ ├── multiply_sample.stan │ ├── new │ │ ├── arg-decl-bad1.stan │ │ ├── blocks-bad1.stan │ │ ├── blocks-bad10.stan │ │ ├── blocks-bad11.stan │ │ ├── blocks-bad12.stan │ │ ├── blocks-bad2.stan │ │ ├── blocks-bad3.stan │ │ ├── blocks-bad4.stan │ │ ├── blocks-bad5.stan │ │ ├── blocks-bad6.stan │ │ ├── blocks-bad7.stan │ │ ├── blocks-bad8.stan │ │ ├── blocks-bad9.stan │ │ ├── dune │ │ ├── fatal_error-bad1.stan │ │ ├── fatal_error-bad2.stan │ │ ├── fun-app-bad1.stan │ │ ├── fun-app-bad2.stan │ │ ├── fun-app-bad3.stan │ │ ├── fun-app-bad4.stan │ │ ├── fun-app-bad5.stan │ │ ├── fun-app-bad6.stan │ │ ├── fun-app-bad7.stan │ │ ├── fun-app-bad8.stan │ │ ├── fun-app-bad9.stan │ │ ├── fundef-bad10.stan │ │ ├── fundef-bad2.stan │ │ ├── fundef-bad3.stan │ │ ├── fundef-bad4.stan │ │ ├── fundef-bad5.stan │ │ ├── fundef-bad6.stan │ │ ├── fundef-bad7.stan │ │ ├── fundef-bad8.stan │ │ ├── fundef-bad9.stan │ │ ├── ill-formed-expression1.stan │ │ ├── ill-formed-expression10.stan │ │ ├── ill-formed-expression11.stan │ │ ├── ill-formed-expression12.stan │ │ ├── ill-formed-expression13.stan │ │ ├── ill-formed-expression14.stan │ │ ├── ill-formed-expression15.stan │ │ ├── ill-formed-expression16.stan │ │ ├── ill-formed-expression17.stan │ │ ├── ill-formed-expression18.stan │ │ ├── ill-formed-expression19.stan │ │ ├── ill-formed-expression2.stan │ │ ├── ill-formed-expression20.stan │ │ ├── ill-formed-expression21.stan │ │ ├── ill-formed-expression22.stan │ │ ├── ill-formed-expression23.stan │ │ ├── ill-formed-expression24.stan │ │ ├── ill-formed-expression25.stan │ │ ├── ill-formed-expression28.stan │ │ ├── ill-formed-expression29.stan │ │ ├── ill-formed-expression3.stan │ │ ├── ill-formed-expression30.stan │ │ ├── ill-formed-expression31.stan │ │ ├── ill-formed-expression32.stan │ │ ├── ill-formed-expression33.stan │ │ ├── ill-formed-expression34.stan │ │ ├── ill-formed-expression35.stan │ │ ├── ill-formed-expression36.stan │ │ ├── ill-formed-expression37.stan │ │ ├── ill-formed-expression38.stan │ │ ├── ill-formed-expression39.stan │ │ ├── ill-formed-expression4.stan │ │ ├── ill-formed-expression40.stan │ │ ├── ill-formed-expression41.stan │ │ ├── ill-formed-expression42.stan │ │ ├── ill-formed-expression43.stan │ │ ├── ill-formed-expression44.stan │ │ ├── ill-formed-expression45.stan │ │ ├── ill-formed-expression46.stan │ │ ├── ill-formed-expression47.stan │ │ ├── ill-formed-expression48.stan │ │ ├── ill-formed-expression49.stan │ │ ├── ill-formed-expression5.stan │ │ ├── ill-formed-expression50.stan │ │ ├── ill-formed-expression51.stan │ │ ├── ill-formed-expression52.stan │ │ ├── ill-formed-expression53.stan │ │ ├── ill-formed-expression54.stan │ │ ├── ill-formed-expression55.stan │ │ ├── ill-formed-expression56.stan │ │ ├── ill-formed-expression57.stan │ │ ├── ill-formed-expression58.stan │ │ ├── ill-formed-expression59.stan │ │ ├── ill-formed-expression6.stan │ │ ├── ill-formed-expression60.stan │ │ ├── ill-formed-expression61.stan │ │ ├── ill-formed-expression62.stan │ │ ├── ill-formed-expression63.stan │ │ ├── ill-formed-expression64.stan │ │ ├── ill-formed-expression65.stan │ │ ├── ill-formed-expression66.stan │ │ ├── ill-formed-expression67.stan │ │ ├── ill-formed-expression68.stan │ │ ├── ill-formed-expression69.stan │ │ ├── ill-formed-expression7.stan │ │ ├── ill-formed-expression70.stan │ │ ├── ill-formed-expression71.stan │ │ ├── ill-formed-expression72.stan │ │ ├── ill-formed-expression73.stan │ │ ├── ill-formed-expression74.stan │ │ ├── ill-formed-expression75.stan │ │ ├── ill-formed-expression76.stan │ │ ├── ill-formed-expression77.stan │ │ ├── ill-formed-expression78.stan │ │ ├── ill-formed-expression79.stan │ │ ├── ill-formed-expression8.stan │ │ ├── ill-formed-expression80.stan │ │ ├── ill-formed-expression81.stan │ │ ├── ill-formed-expression82.stan │ │ ├── ill-formed-expression83.stan │ │ ├── ill-formed-expression84.stan │ │ ├── ill-formed-expression85.stan │ │ ├── ill-formed-expression86.stan │ │ ├── ill-formed-expression87.stan │ │ ├── ill-formed-expression88.stan │ │ ├── ill-formed-expression89.stan │ │ ├── ill-formed-expression9.stan │ │ ├── ill-formed-expression90.stan │ │ ├── ill-formed-expression91.stan │ │ ├── ill-formed-expression92.stan │ │ ├── ill-formed-expression93.stan │ │ ├── ill-formed-expression94.stan │ │ ├── ill-formed-statement1.stan │ │ ├── ill-formed-statement10.stan │ │ ├── ill-formed-statement11.stan │ │ ├── ill-formed-statement12.stan │ │ ├── ill-formed-statement13.stan │ │ ├── ill-formed-statement14.stan │ │ ├── ill-formed-statement15.stan │ │ ├── ill-formed-statement16.stan │ │ ├── ill-formed-statement17.stan │ │ ├── ill-formed-statement18.stan │ │ ├── ill-formed-statement19.stan │ │ ├── ill-formed-statement2.stan │ │ ├── ill-formed-statement20.stan │ │ ├── ill-formed-statement23.stan │ │ ├── ill-formed-statement24.stan │ │ ├── ill-formed-statement25.stan │ │ ├── ill-formed-statement26.stan │ │ ├── ill-formed-statement27.stan │ │ ├── ill-formed-statement28.stan │ │ ├── ill-formed-statement3.stan │ │ ├── ill-formed-statement30.stan │ │ ├── ill-formed-statement35.stan │ │ ├── ill-formed-statement4.stan │ │ ├── ill-formed-statement5.stan │ │ ├── ill-formed-statement6.stan │ │ ├── ill-formed-statement7.stan │ │ ├── ill-formed-statement8.stan │ │ ├── ill-formed-statement9.stan │ │ ├── immediate_error.stan │ │ ├── indices-bad1.stan │ │ ├── indices-bad2.stan │ │ ├── indices-bad3.stan │ │ ├── lexing_error.stan │ │ ├── location-scale-bad1.stan │ │ ├── location-scale-bad10.stan │ │ ├── location-scale-bad11.stan │ │ ├── location-scale-bad2.stan │ │ ├── location-scale-bad3.stan │ │ ├── location-scale-bad4.stan │ │ ├── location-scale-bad5.stan │ │ ├── location-scale-bad6.stan │ │ ├── location-scale-bad7.stan │ │ ├── location-scale-bad8.stan │ │ ├── location-scale-bad9.stan │ │ ├── missing-name.stan │ │ ├── mystery1.stan │ │ ├── mystery10.stan │ │ ├── mystery100.stan │ │ ├── mystery101.stan │ │ ├── mystery102.stan │ │ ├── mystery103.stan │ │ ├── mystery104.stan │ │ ├── mystery105.stan │ │ ├── mystery106.stan │ │ ├── mystery107.stan │ │ ├── mystery108.stan │ │ ├── mystery109.stan │ │ ├── mystery11.stan │ │ ├── mystery12.stan │ │ ├── mystery13.stan │ │ ├── mystery14.stan │ │ ├── mystery15.stan │ │ ├── mystery16.stan │ │ ├── mystery17.stan │ │ ├── mystery18.stan │ │ ├── mystery19.stan │ │ ├── mystery2.stan │ │ ├── mystery20.stan │ │ ├── mystery21.stan │ │ ├── mystery22.stan │ │ ├── mystery23.stan │ │ ├── mystery24.stan │ │ ├── mystery25.stan │ │ ├── mystery26.stan │ │ ├── mystery27.stan │ │ ├── mystery28.stan │ │ ├── mystery29.stan │ │ ├── mystery3.stan │ │ ├── mystery30.stan │ │ ├── mystery31.stan │ │ ├── mystery32.stan │ │ ├── mystery33.stan │ │ ├── mystery34.stan │ │ ├── mystery35.stan │ │ ├── mystery36.stan │ │ ├── mystery37.stan │ │ ├── mystery38.stan │ │ ├── mystery39.stan │ │ ├── mystery4.stan │ │ ├── mystery40.stan │ │ ├── mystery41.stan │ │ ├── mystery42.stan │ │ ├── mystery43.stan │ │ ├── mystery44.stan │ │ ├── mystery45.stan │ │ ├── mystery46.stan │ │ ├── mystery47.stan │ │ ├── mystery48.stan │ │ ├── mystery49.stan │ │ ├── mystery5.stan │ │ ├── mystery50.stan │ │ ├── mystery51.stan │ │ ├── mystery52.stan │ │ ├── mystery53.stan │ │ ├── mystery54.stan │ │ ├── mystery55.stan │ │ ├── mystery56.stan │ │ ├── mystery57.stan │ │ ├── mystery58.stan │ │ ├── mystery59.stan │ │ ├── mystery6.stan │ │ ├── mystery60.stan │ │ ├── mystery61.stan │ │ ├── mystery62.stan │ │ ├── mystery63.stan │ │ ├── mystery64.stan │ │ ├── mystery65.stan │ │ ├── mystery66.stan │ │ ├── mystery67.stan │ │ ├── mystery68.stan │ │ ├── mystery69.stan │ │ ├── mystery7.stan │ │ ├── mystery70.stan │ │ ├── mystery71.stan │ │ ├── mystery72.stan │ │ ├── mystery73.stan │ │ ├── mystery74.stan │ │ ├── mystery75.stan │ │ ├── mystery76.stan │ │ ├── mystery77.stan │ │ ├── mystery78.stan │ │ ├── mystery79.stan │ │ ├── mystery8.stan │ │ ├── mystery80.stan │ │ ├── mystery81.stan │ │ ├── mystery82.stan │ │ ├── mystery83.stan │ │ ├── mystery84.stan │ │ ├── mystery85.stan │ │ ├── mystery86.stan │ │ ├── mystery87.stan │ │ ├── mystery88.stan │ │ ├── mystery89.stan │ │ ├── mystery9.stan │ │ ├── mystery90.stan │ │ ├── mystery91.stan │ │ ├── mystery92.stan │ │ ├── mystery93.stan │ │ ├── mystery94.stan │ │ ├── mystery95.stan │ │ ├── mystery96.stan │ │ ├── mystery97.stan │ │ ├── mystery98.stan │ │ ├── mystery99.stan │ │ ├── print-bad1.stan │ │ ├── print-bad2.stan │ │ ├── print-bad3.stan │ │ ├── print-bad4.stan │ │ ├── print-bad5.stan │ │ ├── print-bad6.stan │ │ ├── reject-bad1.stan │ │ ├── reject-bad2.stan │ │ ├── reject-bad3.stan │ │ ├── reject-bad4.stan │ │ ├── reject-bad5.stan │ │ ├── reject-bad6.stan │ │ ├── reject-bad7.stan │ │ ├── reject-bad8.stan │ │ ├── return-bad1.stan │ │ ├── stanc.expected │ │ ├── statement-in-data-block-bad.stan │ │ ├── statement-outside-of-block-bad1.stan │ │ ├── statement-outside-of-block-bad2.stan │ │ ├── target-bad1.stan │ │ ├── target-bad2.stan │ │ ├── target-pe-bad1.stan │ │ ├── target-pe-bad2.stan │ │ ├── target-pe-bad3.stan │ │ ├── target-pe-bad4.stan │ │ ├── tilde-bad1.stan │ │ ├── tilde-bad10.stan │ │ ├── tilde-bad11.stan │ │ ├── tilde-bad12.stan │ │ ├── tilde-bad13.stan │ │ ├── tilde-bad14.stan │ │ ├── tilde-bad15.stan │ │ ├── tilde-bad16.stan │ │ ├── tilde-bad17.stan │ │ ├── tilde-bad18.stan │ │ ├── tilde-bad19.stan │ │ ├── tilde-bad2.stan │ │ ├── tilde-bad3.stan │ │ ├── tilde-bad4.stan │ │ ├── tilde-bad5.stan │ │ ├── tilde-bad6.stan │ │ ├── tilde-bad7.stan │ │ ├── tilde-bad8.stan │ │ ├── tilde-bad9.stan │ │ ├── transformations-bad1.stan │ │ ├── transformations-bad10.stan │ │ ├── transformations-bad11.stan │ │ ├── transformations-bad12.stan │ │ ├── transformations-bad13.stan │ │ ├── transformations-bad14.stan │ │ ├── transformations-bad15.stan │ │ ├── transformations-bad16.stan │ │ ├── transformations-bad17.stan │ │ ├── transformations-bad2.stan │ │ ├── transformations-bad3.stan │ │ ├── transformations-bad4.stan │ │ ├── transformations-bad5.stan │ │ ├── transformations-bad6.stan │ │ ├── transformations-bad7.stan │ │ ├── transformations-bad8.stan │ │ ├── transformations-bad9.stan │ │ ├── type-bad1.stan │ │ ├── type-size-bad1.stan │ │ ├── type-size-bad10.stan │ │ ├── type-size-bad11.stan │ │ ├── type-size-bad12.stan │ │ ├── type-size-bad13.stan │ │ ├── type-size-bad14.stan │ │ ├── type-size-bad15.stan │ │ ├── type-size-bad16.stan │ │ ├── type-size-bad17.stan │ │ ├── type-size-bad18.stan │ │ ├── type-size-bad19.stan │ │ ├── type-size-bad2.stan │ │ ├── type-size-bad20.stan │ │ ├── type-size-bad21.stan │ │ ├── type-size-bad22.stan │ │ ├── type-size-bad23.stan │ │ ├── type-size-bad24.stan │ │ ├── type-size-bad25.stan │ │ ├── type-size-bad26.stan │ │ ├── type-size-bad27.stan │ │ ├── type-size-bad28.stan │ │ ├── type-size-bad29.stan │ │ ├── type-size-bad3.stan │ │ ├── type-size-bad30.stan │ │ ├── type-size-bad32.stan │ │ ├── type-size-bad34.stan │ │ ├── type-size-bad35.stan │ │ ├── type-size-bad36.stan │ │ ├── type-size-bad37.stan │ │ ├── type-size-bad38.stan │ │ ├── type-size-bad39.stan │ │ ├── type-size-bad4.stan │ │ ├── type-size-bad40.stan │ │ ├── type-size-bad41.stan │ │ ├── type-size-bad42.stan │ │ ├── type-size-bad43.stan │ │ ├── type-size-bad44.stan │ │ ├── type-size-bad45.stan │ │ ├── type-size-bad46.stan │ │ ├── type-size-bad47.stan │ │ ├── type-size-bad48.stan │ │ ├── type-size-bad49.stan │ │ ├── type-size-bad5.stan │ │ ├── type-size-bad50.stan │ │ ├── type-size-bad51.stan │ │ ├── type-size-bad52.stan │ │ ├── type-size-bad53.stan │ │ ├── type-size-bad54.stan │ │ ├── type-size-bad55.stan │ │ ├── type-size-bad56.stan │ │ ├── type-size-bad57.stan │ │ ├── type-size-bad58.stan │ │ ├── type-size-bad59.stan │ │ ├── type-size-bad6.stan │ │ ├── type-size-bad60.stan │ │ ├── type-size-bad61.stan │ │ ├── type-size-bad62.stan │ │ ├── type-size-bad7.stan │ │ ├── type-size-bad8.stan │ │ ├── type-size-bad9.stan │ │ ├── variable-decl-bad1.stan │ │ ├── variable-decl-bad2.stan │ │ ├── variable-decl-bad4.stan │ │ ├── variable-decl-bad5.stan │ │ ├── variable-decl-bad6.stan │ │ ├── variable-decl-bad7.stan │ │ ├── while-bad1.stan │ │ ├── while-bad2.stan │ │ ├── while-bad3.stan │ │ ├── while-bad4.stan │ │ ├── while-bad5.stan │ │ └── while-bad6.stan │ ├── noninfinite_loop_return.stan │ ├── noninfinite_loop_return2.stan │ ├── noninfinite_loop_return3.stan │ ├── noninfinite_loop_return4.stan │ ├── numeric-literal │ │ ├── dune │ │ ├── int-bad1.stan │ │ ├── int-bad2.stan │ │ ├── int-bad3.stan │ │ ├── int-bad4.stan │ │ ├── int-bad6.stan │ │ ├── real-bad1.stan │ │ ├── real-bad2.stan │ │ ├── real-bad3.stan │ │ ├── real-bad4.stan │ │ ├── real-bad5.stan │ │ ├── real-bad6.stan │ │ └── stanc.expected │ ├── ode │ │ ├── adams │ │ │ ├── bad_adams_control_function_return.stan │ │ │ ├── bad_control_function_return.stan │ │ │ ├── bad_fun_type.stan │ │ │ ├── bad_fun_type_control.stan │ │ │ ├── bad_t_type.stan │ │ │ ├── bad_t_type_control.stan │ │ │ ├── bad_theta_type.stan │ │ │ ├── bad_theta_type_control.stan │ │ │ ├── bad_ts_type.stan │ │ │ ├── bad_ts_type_control.stan │ │ │ ├── bad_x_int_type.stan │ │ │ ├── bad_x_int_type_control.stan │ │ │ ├── bad_x_type.stan │ │ │ ├── bad_x_type_control.stan │ │ │ ├── bad_x_var_type.stan │ │ │ ├── bad_x_var_type_adams_control.stan │ │ │ ├── bad_x_var_type_control.stan │ │ │ ├── bad_y_type.stan │ │ │ ├── bad_y_type_control.stan │ │ │ ├── dune │ │ │ └── stanc.expected │ │ ├── bad_bdf_control_function_return.stan │ │ ├── bad_fun_type.stan │ │ ├── bad_fun_type_bdf.stan │ │ ├── bad_fun_type_bdf_control.stan │ │ ├── bad_fun_type_rk45.stan │ │ ├── bad_fun_type_rk45_control.stan │ │ ├── bad_t_type.stan │ │ ├── bad_t_type_bdf.stan │ │ ├── bad_t_type_bdf_control.stan │ │ ├── bad_t_type_rk45.stan │ │ ├── bad_t_type_rk45_control.stan │ │ ├── bad_theta_type.stan │ │ ├── bad_theta_type_bdf.stan │ │ ├── bad_theta_type_bdf_control.stan │ │ ├── bad_theta_type_rk45.stan │ │ ├── bad_theta_type_rk45_control.stan │ │ ├── bad_ts_type.stan │ │ ├── bad_ts_type_bdf.stan │ │ ├── bad_ts_type_bdf_control.stan │ │ ├── bad_ts_type_rk45.stan │ │ ├── bad_ts_type_rk45_control.stan │ │ ├── bad_var_tol_1.stan │ │ ├── bad_var_tol_2.stan │ │ ├── bad_var_tol_3.stan │ │ ├── bad_x_int_type.stan │ │ ├── bad_x_int_type_bdf.stan │ │ ├── bad_x_int_type_bdf_control.stan │ │ ├── bad_x_int_type_rk45.stan │ │ ├── bad_x_int_type_rk45_control.stan │ │ ├── bad_x_type.stan │ │ ├── bad_x_type_bdf.stan │ │ ├── bad_x_type_bdf_control.stan │ │ ├── bad_x_type_rk45.stan │ │ ├── bad_x_type_rk45_control.stan │ │ ├── bad_x_var_type.stan │ │ ├── bad_x_var_type_bdf.stan │ │ ├── bad_x_var_type_bdf_control.stan │ │ ├── bad_x_var_type_rk45.stan │ │ ├── bad_x_var_type_rk45_control.stan │ │ ├── bad_y_type.stan │ │ ├── bad_y_type_bdf.stan │ │ ├── bad_y_type_bdf_control.stan │ │ ├── bad_y_type_rk45.stan │ │ ├── bad_y_type_rk45_control.stan │ │ ├── dune │ │ └── stanc.expected │ ├── oneline-error.stan │ ├── op_addition_bad.stan │ ├── op_divide_bad.stan │ ├── op_divide_right_bad.stan │ ├── op_elt_divide_bad.stan │ ├── op_elt_multiply_bad.stan │ ├── op_intdivide_bad.stan │ ├── op_intdivide_bad_1.stan │ ├── op_intdivide_bad_2.stan │ ├── op_intdivide_bad_3.stan │ ├── op_logical_negation_bad.stan │ ├── op_mdivide_left_bad.stan │ ├── op_modulus_bad.stan │ ├── op_multiplication_bad.stan │ ├── op_subtraction_bad.stan │ ├── op_transpose_bad.stan │ ├── print-bad.stan │ ├── print-void.stan │ ├── prob-fun-args-no-bar.stan │ ├── prob-poisson_log-trunc-both.stan │ ├── prob-poisson_log-trunc-high.stan │ ├── prob-poisson_log-trunc-low.stan │ ├── profiling │ │ ├── dune │ │ ├── profile-bad1.stan │ │ ├── profile-bad2.stan │ │ ├── profile-bad3.stan │ │ ├── profile-bad4.stan │ │ ├── profile-bad5.stan │ │ ├── profile-bad6.stan │ │ └── stanc.expected │ ├── real-pdf.stan │ ├── real-pmf.stan │ ├── real_idx.stan │ ├── reduce_sum │ │ ├── bad_args_length_mismatch.stan │ │ ├── bad_args_length_mismatch2.stan │ │ ├── bad_args_length_mismatch2_static.stan │ │ ├── bad_args_length_mismatch_static.stan │ │ ├── bad_fun_1.stan │ │ ├── bad_fun_1_static.stan │ │ ├── bad_fun_first_arg.stan │ │ ├── bad_fun_first_arg_static.stan │ │ ├── bad_fun_second_arg.stan │ │ ├── bad_fun_second_arg_static.stan │ │ ├── bad_fun_slice_and_slice_dont_match.stan │ │ ├── bad_fun_slice_and_slice_dont_match_static.stan │ │ ├── bad_non_matching_arg_types.stan │ │ ├── bad_non_matching_arg_types2.stan │ │ ├── bad_non_matching_arg_types2_static.stan │ │ ├── bad_non_matching_arg_types3.stan │ │ ├── bad_non_matching_arg_types3_static.stan │ │ ├── bad_not_slice_type.stan │ │ ├── bad_not_slice_type_static.stan │ │ ├── bad_reduce_sum_multiple.stan │ │ ├── bad_return_type.stan │ │ ├── bad_return_type_static.stan │ │ ├── bad_slice_type.stan │ │ ├── bad_suffix.stan │ │ ├── bad_userdefined_reduce_sum.stan │ │ ├── bad_userdefined_reduce_sum_static.stan │ │ ├── dune │ │ └── stanc.expected │ ├── removed_features │ │ ├── abs-deprecate.stan │ │ ├── binomial_coefficient_log.stan │ │ ├── cdf_conditioning.stan │ │ ├── cov_exp_quad.stan │ │ ├── decl.stan │ │ ├── declarations.stan │ │ ├── deprecated_tilde.stan │ │ ├── dune │ │ ├── duplicate-warns.stan │ │ ├── get-lp-deprecate.stan │ │ ├── get_lp_target.stan │ │ ├── identifiers.stan │ │ ├── if_else.stan │ │ ├── increment_log_prob.stan │ │ ├── lvalue_multiindex.stan │ │ ├── multiply_log.stan │ │ ├── old-log-funs.stan │ │ ├── pound-comment-deprecated.stan │ │ ├── real-bools.stan │ │ ├── removed_deprecated_syntax.stan │ │ ├── stanc.expected │ │ ├── unreserved-array-keyword.stan │ │ ├── unsized-old-array.stan │ │ └── unsized-old-array2.stan │ ├── reserved │ │ ├── auto.stan │ │ ├── break.stan │ │ ├── cholesky_factor_corr.stan │ │ ├── cholesky_factor_cov.stan │ │ ├── column_stochastic_matrix.stan │ │ ├── continue.stan │ │ ├── corr_matrix.stan │ │ ├── cov_matrix.stan │ │ ├── data.stan │ │ ├── dune │ │ ├── else.stan │ │ ├── export.stan │ │ ├── extern.stan │ │ ├── false.stan │ │ ├── for.stan │ │ ├── generated.stan │ │ ├── if.stan │ │ ├── in.stan │ │ ├── int.stan │ │ ├── matrix.stan │ │ ├── model.stan │ │ ├── ordered.stan │ │ ├── parameters.stan │ │ ├── positive_ordered.stan │ │ ├── quantities.stan │ │ ├── real.stan │ │ ├── repeat.stan │ │ ├── return.stan │ │ ├── row_stochastic_matrix.stan │ │ ├── row_vector.stan │ │ ├── simplex.stan │ │ ├── stanc.expected │ │ ├── static.stan │ │ ├── struct.stan │ │ ├── sum_to_zero_matrix.stan │ │ ├── sum_to_zero_vector.stan │ │ ├── then.stan │ │ ├── transformed.stan │ │ ├── true.stan │ │ ├── typedef.stan │ │ ├── unit_vector.stan │ │ ├── until.stan │ │ ├── var.stan │ │ ├── vector.stan │ │ ├── void.stan │ │ └── while.stan │ ├── rng-no-suffix.stan │ ├── rng_loc1.stan │ ├── rng_loc2.stan │ ├── rng_loc3.stan │ ├── rng_loc4.stan │ ├── rng_loc5.stan │ ├── rng_loc6.stan │ ├── row_vector_expr_bad1.stan │ ├── row_vector_expr_bad2.stan │ ├── shadow.stan │ ├── signature_function_known.stan │ ├── signature_function_unknown.stan │ ├── signature_sampling_known.stan │ ├── signature_sampling_reserved.stan │ ├── signature_sampling_udf.stan │ ├── signature_sampling_unknown.stan │ ├── signature_sampling_unknown2.stan │ ├── stanc.expected │ ├── stanc_helper.stan │ ├── string_literal_newline.stan │ ├── tabs_error_line.stan │ ├── target-reserved.stan │ ├── target_pe_bad.stan │ ├── ternaryif-fntype.stan │ ├── tilde-bad.stan │ ├── too-many-indices.stan │ ├── truncation-bad-type1.stan │ ├── truncation-bad-type2.stan │ ├── truncation-bad-type3.stan │ ├── truncation-bad-type4.stan │ ├── truncation-bad-type5.stan │ ├── truncation_missing_overloads.stan │ ├── tuples │ │ ├── array_literal_mismatch.stan │ │ ├── bad-arg.stan │ │ ├── bad-index1.stan │ │ ├── bad-index2.stan │ │ ├── bad-index3.stan │ │ ├── bad-index4.stan │ │ ├── bad-index5.stan │ │ ├── bad_addition.stan │ │ ├── bad_unpack_duplicates.stan │ │ ├── bad_unpack_fn_type.stan │ │ ├── bad_unpack_global.stan │ │ ├── bad_unpack_lhs.stan │ │ ├── bad_unpack_overlap1.stan │ │ ├── bad_unpack_overlap2.stan │ │ ├── bad_unpack_read_write.stan │ │ ├── bad_unpack_read_write2.stan │ │ ├── bad_unpack_read_write3.stan │ │ ├── bad_unpack_shape.stan │ │ ├── bad_unpack_tuple_overlap1.stan │ │ ├── bad_unpack_tuple_overlap2.stan │ │ ├── bad_unpack_types.stan │ │ ├── dune │ │ ├── empty_tuple_expr.stan │ │ ├── empty_tuple_type.stan │ │ ├── fn-assign.stan │ │ ├── function-mismatch1.stan │ │ ├── fuzz-tuple-idx1.stan │ │ ├── fuzz-tuple-idx2.stan │ │ ├── fuzz-tuple-idx3.stan │ │ ├── incomplete1.stan │ │ ├── incomplete2.stan │ │ ├── incomplete3.stan │ │ ├── incomplete4.stan │ │ ├── incomplete5.stan │ │ ├── incomplete6.stan │ │ ├── incomplete7.stan │ │ ├── onepl_expr.stan │ │ ├── onepl_type.stan │ │ ├── onepl_type2.stan │ │ ├── onepl_type_missing_comma.stan │ │ ├── stanc.expected │ │ ├── tuple-dataonly-ad.stan │ │ ├── tuple-dataonly-ad2.stan │ │ └── tuple_ternary.stan │ ├── typo.stan │ ├── unnormalized │ │ ├── dune │ │ ├── lupdf_ident.stan │ │ ├── lupdf_in_functions.stan │ │ ├── lupdf_in_gq.stan │ │ ├── lupdf_in_gq_rs.stan │ │ ├── lupdf_in_lp.stan │ │ ├── lupdf_in_trans_data.stan │ │ ├── lupdf_in_trans_params.stan │ │ ├── lupdf_in_trans_params_rs.stan │ │ ├── lupmf_in_gq.stan │ │ ├── lupmf_in_lp.stan │ │ ├── lupmf_in_trans_data.stan │ │ ├── lupmf_in_trans_params.stan │ │ ├── stanc.expected │ │ ├── udf_lupdf.stan │ │ └── udf_lupmf.stan │ ├── validate_add_expression_dimss_bad.stan │ ├── validate_add_var_bad1.stan │ ├── validate_add_var_bad2.stan │ ├── validate_allow_sample_bad1.stan │ ├── validate_allow_sample_bad2.stan │ ├── validate_allow_sample_bad3.stan │ ├── validate_array_expr_bad1.stan │ ├── validate_array_expr_bad2.stan │ ├── validate_array_expr_bad3.stan │ ├── validate_array_expr_bad3a.stan │ ├── validate_conditional_op_bad-1.stan │ ├── validate_conditional_op_bad-2.stan │ ├── validate_exponentiation_bad.stan │ ├── validate_int_expr2_bad1.stan │ ├── validate_int_expr2_bad2.stan │ ├── validate_int_expr2_bad3.stan │ ├── validate_int_expr2_bad4.stan │ ├── validate_logical_negate_expr_bad.stan │ ├── validate_modulus_bad.stan │ ├── validate_set_double_offset_multiplier_bad1.stan │ ├── validate_set_double_offset_multiplier_bad2.stan │ ├── validate_set_double_offset_multiplier_bad3.stan │ ├── validate_set_double_range_lower_bad1.stan │ ├── validate_set_double_range_lower_bad2.stan │ ├── validate_set_double_range_upper_bad1.stan │ ├── validate_set_double_range_upper_bad2.stan │ ├── validate_set_int_range_lower_bad1.stan │ ├── validate_set_int_range_lower_bad2.stan │ ├── validate_set_int_range_lower_bad3.stan │ ├── validate_set_int_range_upper_bad1.stan │ ├── validate_set_int_range_upper_bad2.stan │ ├── validate_validate_int_expr_bad1.stan │ ├── validate_validate_int_expr_bad10.stan │ ├── validate_validate_int_expr_bad11.stan │ ├── validate_validate_int_expr_bad12.stan │ ├── validate_validate_int_expr_bad13.stan │ ├── validate_validate_int_expr_bad2.stan │ ├── validate_validate_int_expr_bad3.stan │ ├── validate_validate_int_expr_bad4.stan │ ├── validate_validate_int_expr_bad5.stan │ ├── validate_validate_int_expr_bad6.stan │ ├── validate_validate_int_expr_bad7.stan │ ├── validate_validate_int_expr_bad8.stan │ ├── validate_validate_int_expr_bad9.stan │ ├── var-decl-bad-1.stan │ ├── var-decl-bad-2.stan │ ├── variadic_dae │ │ ├── bad_abs_tol.stan │ │ ├── bad_initial_derivative.stan │ │ ├── bad_initial_state.stan │ │ ├── bad_initial_time.stan │ │ ├── bad_max_num_steps.stan │ │ ├── bad_no_args.stan │ │ ├── bad_non_matching_args.stan │ │ ├── bad_rel_tol.stan │ │ ├── bad_time0.stan │ │ ├── bad_times_param.stan │ │ ├── bad_times_tol.stan │ │ ├── dune │ │ └── stanc.expected │ └── variadic_ode │ │ ├── bad_abs_tol.stan │ │ ├── bad_initial_state.stan │ │ ├── bad_initial_time.stan │ │ ├── bad_max_num_steps.stan │ │ ├── bad_no_args.stan │ │ ├── bad_non_matching_args.stan │ │ ├── bad_one_arg.stan │ │ ├── bad_rel_tol.stan │ │ ├── bad_times.stan │ │ ├── bad_times_tol.stan │ │ ├── dune │ │ └── stanc.expected ├── cli-args │ ├── allow-undefined │ │ ├── cpp.expected │ │ ├── dune │ │ ├── external.stan │ │ └── standalone-cpp.expected │ ├── canonicalize │ │ ├── blocks.stan │ │ ├── canonical.expected │ │ ├── canonicalize.t │ │ ├── deprecated.stan │ │ ├── deprecations-only.expected │ │ ├── dune │ │ ├── everything-but.expected │ │ ├── funs.stanfunctions │ │ ├── include │ │ │ ├── a.stanfunctions │ │ │ ├── b.stanfunctions │ │ │ ├── c.stanfunctions │ │ │ ├── dune │ │ │ ├── first.stanfunctions │ │ │ ├── inlined.expected │ │ │ ├── main.stan │ │ │ ├── main2.stan │ │ │ ├── second.stanfunctions │ │ │ ├── stanc.expected │ │ │ ├── statements1.inc │ │ │ ├── statements2.inc │ │ │ ├── tdata.stan │ │ │ └── tildes.inc │ │ ├── parenthesize.stan │ │ ├── squaremc.stan │ │ └── strip-comments.expected │ ├── debug-flags.t │ │ ├── basic.stan │ │ ├── parse_error.stan │ │ └── run.t │ ├── debug-generation.t │ │ ├── bad.json │ │ ├── debug.stan │ │ ├── div0.stan │ │ ├── incomplete_data.json │ │ ├── partial-div0.json │ │ ├── partial_data.json │ │ └── run.t │ ├── dune │ ├── filename-in-msg │ │ ├── also_empty.stan │ │ ├── dune │ │ ├── empty.stan │ │ ├── filename_error.expected │ │ ├── filename_error.stan │ │ ├── filename_good.expected │ │ ├── filename_good.stan │ │ ├── filename_syntax_error.stan │ │ └── includes.stan │ ├── info │ │ ├── dune │ │ ├── included.stan │ │ ├── includes │ │ │ ├── another_include.stan │ │ │ └── recursive.stan │ │ ├── info.expected │ │ └── info.stan │ ├── max-line-length │ │ ├── dune │ │ ├── long.expected │ │ ├── mother.stan │ │ └── short.expected │ ├── model-name │ │ ├── 8start_with_number.stan │ │ ├── bad.stan │ │ ├── dune │ │ ├── good.stan │ │ ├── stanc.expected │ │ └── stanc.t │ ├── notfound.expected │ ├── output-files.t │ │ ├── basic.stan │ │ └── run.t │ ├── stanc.t │ ├── warn-pedantic │ │ ├── distribution-warnings.stan │ │ ├── distribution_bounds.stan │ │ ├── dune │ │ ├── function-param-control-flow.stan │ │ ├── gamma-args.stan │ │ ├── hard-constraint.stan │ │ ├── jacobian_false_alarm.stan │ │ ├── jacobian_warning1.stan │ │ ├── jacobian_warning2.stan │ │ ├── jacobian_warning3.stan │ │ ├── jacobian_warning4.stan │ │ ├── jacobian_warning5.stan │ │ ├── jacobian_warning6.stan │ │ ├── jacobian_warning7.stan │ │ ├── jacobian_warning_user.stan │ │ ├── lp_fun.stan │ │ ├── missing-prior-false-alarm.stan │ │ ├── missing_priors.stan │ │ ├── multi-tilde.stan │ │ ├── non-one-priors.stan │ │ ├── non-one-priors2.stan │ │ ├── param-depend-control.stan │ │ ├── stanc.expected │ │ ├── unbounded-sigma.stan │ │ ├── uniform.stan │ │ ├── unscaled.stan │ │ └── unused-param.stan │ └── warn-uninitialized │ │ ├── dune │ │ ├── simple.stan │ │ └── stanc.expected ├── downstream │ ├── dune │ ├── pretty.expected │ ├── prophet.stan │ └── rstanarm │ │ ├── bernoulli.stan │ │ ├── binomial.stan │ │ ├── continuous.stan │ │ ├── count.stan │ │ ├── data │ │ ├── NKX.stan │ │ ├── data_assoc.stan │ │ ├── data_betareg.stan │ │ ├── data_event.stan │ │ ├── data_glm.stan │ │ ├── data_mvmer.stan │ │ ├── dimensions_mvmer.stan │ │ ├── glmer_stuff.stan │ │ ├── glmer_stuff2.stan │ │ ├── hyperparameters.stan │ │ ├── hyperparameters_assoc.stan │ │ ├── hyperparameters_event.stan │ │ ├── hyperparameters_mvmer.stan │ │ └── weights_offset.stan │ │ ├── dune │ │ ├── functions │ │ ├── SSfunctions.stan │ │ ├── bernoulli_likelihoods.stan │ │ ├── binomial_likelihoods.stan │ │ ├── common_functions.stan │ │ ├── continuous_likelihoods.stan │ │ ├── count_likelihoods.stan │ │ ├── jm_functions.stan │ │ └── mvmer_functions.stan │ │ ├── gqs │ │ └── gen_quantities_mvmer.stan │ │ ├── inlined.expected │ │ ├── jm.stan │ │ ├── lm.stan │ │ ├── model │ │ ├── assoc_evaluate.stan │ │ ├── eta_add_Zb.stan │ │ ├── eta_no_intercept.stan │ │ ├── eta_z_no_intercept.stan │ │ ├── event_lp.stan │ │ ├── make_eta.stan │ │ ├── make_eta_bern.stan │ │ ├── make_eta_tmp.stan │ │ ├── make_eta_tmp2.stan │ │ ├── make_eta_z.stan │ │ ├── mvmer_lp.stan │ │ ├── priors_betareg.stan │ │ ├── priors_glm.stan │ │ └── priors_mvmer.stan │ │ ├── mvmer.stan │ │ ├── parameters │ │ ├── parameters_assoc.stan │ │ ├── parameters_betareg.stan │ │ ├── parameters_event.stan │ │ ├── parameters_glm.stan │ │ └── parameters_mvmer.stan │ │ ├── polr.stan │ │ ├── pre │ │ ├── Brilleman_copyright.stan │ │ ├── Columbia_copyright.stan │ │ └── license.stan │ │ ├── pretty.expected │ │ ├── stripped.expected │ │ ├── tdata │ │ ├── tdata_betareg.stan │ │ ├── tdata_glm.stan │ │ └── tdata_mvmer.stan │ │ └── tparameters │ │ ├── tparameters_betareg.stan │ │ ├── tparameters_glm.stan │ │ └── tparameters_mvmer.stan ├── dune ├── good │ ├── algebra_solver_good.stan │ ├── algebra_solver_newton_good.stan │ ├── array-expr │ │ ├── dune │ │ ├── pretty.expected │ │ ├── validate_array_expr_big.stan │ │ ├── validate_array_expr_containers.stan │ │ ├── validate_array_expr_mixed.stan │ │ ├── validate_array_expr_primitives │ │ └── validate_array_expr_primitives.stan │ ├── assignment-new.stan │ ├── assignment_double_index_lhs.stan │ ├── assignments.stan │ ├── assignments_double_var.stan │ ├── assignments_var.stan │ ├── bernoulli_logit_glm_old_performance.stan │ ├── bernoulli_logit_glm_performance.stan │ ├── break-continue.stan │ ├── code-gen │ │ ├── 8_schools_ncp.stan │ │ ├── 8start_with_number.stan │ │ ├── builtin-constraint.stan │ │ ├── cl.expected │ │ ├── complex-tuples.stan │ │ ├── complex_numbers │ │ │ ├── basic_op_param.stan │ │ │ ├── basic_operations.stan │ │ │ ├── basic_ops_mix.stan │ │ │ ├── complex_data.stan │ │ │ ├── complex_scalar.stan │ │ │ ├── complex_vectors.stan │ │ │ ├── cpp.expected │ │ │ ├── dune │ │ │ └── user_function_templating.stan │ │ ├── container-promotion.stan │ │ ├── cpp-overload-stdlib.stan │ │ ├── cpp-reserved-words.stan │ │ ├── cpp.expected │ │ ├── data_only_functions.stan │ │ ├── deprecated_jacobian_usage.stan │ │ ├── double-reject.stan │ │ ├── dune │ │ ├── eight_schools_ncp.stan │ │ ├── expressions │ │ │ ├── cpp.expected │ │ │ ├── dune │ │ │ ├── operators.stan │ │ │ ├── simple_function.stan │ │ │ └── ternary_if.stan │ │ ├── funcall-type-promotion.stan │ │ ├── jacobian_pe.stan │ │ ├── laplace_bernoulli_logit.stan │ │ ├── laplace_functionals.stan │ │ ├── laplace_neg_binomial_2_log.stan │ │ ├── laplace_nested_tuple.stan │ │ ├── laplace_nested_tuple2.stan │ │ ├── laplace_nested_tuple3.stan │ │ ├── laplace_overload_weird.stan │ │ ├── laplace_poisson.stan │ │ ├── laplace_poisson_log.stan │ │ ├── lir.expected │ │ ├── mir.expected │ │ ├── mixed_type_arrays.stan │ │ ├── mother.stan │ │ ├── motherHOF.stan │ │ ├── new_integrate_interface.stan │ │ ├── ode │ │ │ ├── cpp.expected │ │ │ ├── dune │ │ │ ├── ode_adjoint_test_model.stan │ │ │ └── overloaded-ode.stan │ │ ├── old_integrate_interface.stan │ │ ├── opencl │ │ │ ├── cpp.expected │ │ │ ├── distributions.stan │ │ │ ├── dune │ │ │ └── restricted.stan │ │ ├── optimize_glm.stan │ │ ├── overload_tilde_stanlib.stan │ │ ├── overload_tilde_udfs.stan │ │ ├── overloading_templating.stan │ │ ├── param-constraint.stan │ │ ├── print_unicode.stan │ │ ├── profiling │ │ │ ├── cpp.expected │ │ │ ├── dune │ │ │ ├── simple_function.stan │ │ │ └── transformed_mir.expected │ │ ├── promotion.stan │ │ ├── recursive-slicing.stan │ │ ├── reduce_sum_m1.stan │ │ ├── reduce_sum_m2.stan │ │ ├── reduce_sum_m3.stan │ │ ├── reject-exit.stan │ │ ├── return-position-types.stan │ │ ├── self-assign.stan │ │ ├── shadowing.stan │ │ ├── single-argument-lpmf.stan │ │ ├── standalone_functions │ │ │ ├── basic.stan │ │ │ ├── basic.stanfunctions │ │ │ ├── cpp.expected │ │ │ ├── dune │ │ │ ├── integrate.stan │ │ │ └── stanc.expected │ │ ├── stochastic_matrices.stan │ │ ├── sum_to_zero.stan │ │ ├── tilde-block.stan │ │ ├── transform.stan │ │ ├── transformed_mir.expected │ │ ├── truncate.stan │ │ ├── udf_tilde_stmt_conflict.stan │ │ ├── user_constrain.stan │ │ ├── variable_named_context.stan │ │ └── vector_truncate.stan │ ├── comments.stan │ ├── compiler-optimizations │ │ ├── ad-level-deep-dependence.stan │ │ ├── ad-level-failing.stan │ │ ├── ad-levels-deep.stan │ │ ├── copy-prop-profile.stan │ │ ├── copy_fail.stan │ │ ├── cpp.expected │ │ ├── cppO0.expected │ │ ├── cppO1.expected │ │ ├── dce-fail.stan │ │ ├── dune │ │ ├── expr-prop-experiment.stan │ │ ├── expr-prop-experiment2.stan │ │ ├── expr-prop-fail.stan │ │ ├── expr-prop-fail2.stan │ │ ├── expr-prop-fail3.stan │ │ ├── expr-prop-fail4.stan │ │ ├── expr-prop-fail5.stan │ │ ├── expr-prop-fail6.stan │ │ ├── expr-prop-fail7.stan │ │ ├── expr-prop-fail8.stan │ │ ├── fails-test.stan │ │ ├── function-in-function-inline.stan │ │ ├── function-in-function-loops.stan │ │ ├── fuzz-div0.stan │ │ ├── initialize-SoA.stan │ │ ├── inline-functions-varmat.stan │ │ ├── inline-tdata.stan │ │ ├── inliner-same-names.stan │ │ ├── inlining-fail2.stan │ │ ├── lcm-experiment.stan │ │ ├── lcm-experiment2.stan │ │ ├── lcm-fails.stan │ │ ├── lcm-fails2.stan │ │ ├── lupdf-inlining.stan │ │ ├── mem_patterns │ │ │ ├── ad_scalar_data_matrix.stan │ │ │ ├── complex-fails.stan │ │ │ ├── constraints.stan │ │ │ ├── cpp.expected │ │ │ ├── deep_dependence.stan │ │ │ ├── dune │ │ │ ├── indexing.stan │ │ │ ├── indexing2.stan │ │ │ ├── reductions_allowed.stan │ │ │ ├── return_types_and_udfs_demotes.stan │ │ │ ├── single_indexing.stan │ │ │ ├── tp_reused.stan │ │ │ ├── transformed_mir.expected │ │ │ ├── tuple_test.stan │ │ │ └── tuple_test2.stan │ │ ├── off-dce.stan │ │ ├── off-small.stan │ │ ├── optimizations.stan │ │ ├── overload_tilde_stanlib.stan │ │ ├── overloaded-fn.stan │ │ ├── overloaded-fn2.stan │ │ ├── partial-eval-tuple.stan │ │ ├── partial-eval.stan │ │ ├── partial_eval_multiply.stan │ │ ├── partial_eval_zeros.stan │ │ ├── pretty.expected │ │ ├── stalled1-failure.stan │ │ ├── unenforce-initialize-omni.stan │ │ ├── unenforce-initialize-should-fail.stan │ │ ├── unenforce-initialize.stan │ │ └── unroll-limit.stan │ ├── compound-assign │ │ ├── divide_equals_container.stan │ │ ├── divide_equals_manual.stan │ │ ├── divide_equals_prim.stan │ │ ├── divide_equals_print.stan │ │ ├── divide_equals_sliced.stan │ │ ├── dune │ │ ├── elt_divide_equals.stan │ │ ├── elt_divide_equals_sliced.stan │ │ ├── elt_multiply_equals.stan │ │ ├── elt_multiply_equals_sliced.stan │ │ ├── indexed_expr_divide_equals.stan │ │ ├── matrix_compound_assigns.stan │ │ ├── minus_equals_container.stan │ │ ├── minus_equals_manual.stan │ │ ├── minus_equals_prim.stan │ │ ├── minus_equals_sliced.stan │ │ ├── multiply_equals.stan │ │ ├── multiply_equals_container.stan │ │ ├── multiply_equals_manual.stan │ │ ├── multiply_equals_prim.stan │ │ ├── multiply_equals_sliced.stan │ │ ├── plus_equals_container.stan │ │ ├── plus_equals_manual.stan │ │ ├── plus_equals_prim.stan │ │ ├── plus_equals_prim_print.stan │ │ ├── plus_equals_row_vector.stan │ │ ├── plus_equals_sliced.stan │ │ ├── plus_equals_vector.stan │ │ ├── pretty.expected │ │ └── sliced_plus_equals_container.stan │ ├── conditional_condition_good.stan │ ├── conditional_op_fun_promote.stan │ ├── dae_good.stan │ ├── dataonly-int-return.stan │ ├── decl_assign.stan │ ├── declarations.stan │ ├── declare-define-conditional-op.stan │ ├── declare-define-gq-local-rng.stan │ ├── declare-define-multi.stan │ ├── declare-define-var-constrained-matrix.stan │ ├── declare-define-var-constrained-vector.stan │ ├── declare-define-var-double.stan │ ├── declare-define-var-int.stan │ ├── declare-define-var-matrix.stan │ ├── declare-define-var-vec-runtime-error.stan │ ├── declare-define-var-vec-types.stan │ ├── dune │ ├── for_early_return.stan │ ├── for_loops │ │ ├── dune │ │ ├── pretty.expected │ │ ├── x_in_xs_function_block_1.stan │ │ ├── x_in_xs_function_block_2.stan │ │ └── x_in_xs_function_block_3.stan │ ├── fun-defs-lpdf.stan │ ├── fun-return-typ1.stan │ ├── fun-return-typ2.stan │ ├── fun-return-typ4.stan │ ├── fun-var-constraints.stan │ ├── fun_args_0.stan │ ├── fun_args_0_lp.stan │ ├── fun_args_1.stan │ ├── fun_args_4.stan │ ├── fun_args_4_lp.stan │ ├── fun_args_5.stan │ ├── fun_args_5_lp.stan │ ├── fun_args_int0.stan │ ├── fun_args_int_1_int.stan │ ├── fun_args_int_1_real.stan │ ├── fun_as_lhs_sampling.stan │ ├── fun_as_stmt.stan │ ├── function-signatures │ │ ├── README.txt │ │ ├── distributions │ │ │ ├── multivariate │ │ │ │ ├── continuous │ │ │ │ │ ├── dirichlet_lpdf.stan │ │ │ │ │ ├── gaussian_dlm_obs_log.stan │ │ │ │ │ ├── hmm_marginal.stan │ │ │ │ │ ├── inv_wishart_cholesky_lpdf.stan │ │ │ │ │ ├── inv_wishart_log.stan │ │ │ │ │ ├── lkj_corr_cholesky_log.stan │ │ │ │ │ ├── lkj_corr_log.stan │ │ │ │ │ ├── lkj_cov_log.stan │ │ │ │ │ ├── multi_gp_cholesky_lpdf.stan │ │ │ │ │ ├── multi_gp_lpdf.stan │ │ │ │ │ ├── multi_normal_cholesky_lpdf.stan │ │ │ │ │ ├── multi_normal_lpdf.stan │ │ │ │ │ ├── multi_normal_prec_lpdf.stan │ │ │ │ │ ├── multi_student_t_cholesky_lpdf.stan │ │ │ │ │ ├── multi_student_t_lpdf.stan │ │ │ │ │ ├── wishart_cholesky_lpdf.stan │ │ │ │ │ └── wishart_lpdf.stan │ │ │ │ └── discrete │ │ │ │ │ ├── categorical │ │ │ │ │ ├── categorical_logit_glm.stan │ │ │ │ │ ├── categorical_logit_lpmf.stan │ │ │ │ │ └── categorical_lpmf.stan │ │ │ │ │ ├── dirichlet_multinomial │ │ │ │ │ └── dirichlet_multinomial_lpmf.stan │ │ │ │ │ ├── multinomial │ │ │ │ │ ├── multinomial_log.stan │ │ │ │ │ └── multinomial_logit_lpmf.stan │ │ │ │ │ ├── ordered_logistic │ │ │ │ │ ├── ordered_logistic_glm_lpmf.stan │ │ │ │ │ └── ordered_logistic_log.stan │ │ │ │ │ └── ordered_probit │ │ │ │ │ └── ordered_probit_lpmf.stan │ │ │ ├── rngs.stan │ │ │ └── univariate │ │ │ │ ├── continuous │ │ │ │ ├── beta │ │ │ │ │ ├── beta_cdf.stan │ │ │ │ │ ├── beta_lccdf.stan │ │ │ │ │ ├── beta_lcdf.stan │ │ │ │ │ └── beta_lpdf.stan │ │ │ │ ├── beta_proportion │ │ │ │ │ ├── beta_proportion_lccdf.stan │ │ │ │ │ ├── beta_proportion_lcdf.stan │ │ │ │ │ └── beta_proportion_lpdf.stan │ │ │ │ ├── cauchy │ │ │ │ │ ├── cauchy_cdf.stan │ │ │ │ │ ├── cauchy_lccdf.stan │ │ │ │ │ ├── cauchy_lcdf.stan │ │ │ │ │ └── cauchy_lpdf.stan │ │ │ │ ├── chi_square │ │ │ │ │ ├── chi_square_cdf.stan │ │ │ │ │ ├── chi_square_lccdf.stan │ │ │ │ │ ├── chi_square_lcdf.stan │ │ │ │ │ └── chi_square_lpdf.stan │ │ │ │ ├── double_exponential │ │ │ │ │ ├── double_exponential_cdf.stan │ │ │ │ │ ├── double_exponential_lccdf.stan │ │ │ │ │ ├── double_exponential_lcdf.stan │ │ │ │ │ └── double_exponential_lpdf.stan │ │ │ │ ├── exp_mod_normal │ │ │ │ │ ├── exp_mod_normal_ccdf_log_1.stan │ │ │ │ │ ├── exp_mod_normal_ccdf_log_2.stan │ │ │ │ │ ├── exp_mod_normal_ccdf_log_3.stan │ │ │ │ │ ├── exp_mod_normal_ccdf_log_4.stan │ │ │ │ │ ├── exp_mod_normal_cdf_1.stan │ │ │ │ │ ├── exp_mod_normal_cdf_2.stan │ │ │ │ │ ├── exp_mod_normal_cdf_3.stan │ │ │ │ │ ├── exp_mod_normal_cdf_4.stan │ │ │ │ │ ├── exp_mod_normal_cdf_log_1.stan │ │ │ │ │ ├── exp_mod_normal_cdf_log_2.stan │ │ │ │ │ ├── exp_mod_normal_cdf_log_3.stan │ │ │ │ │ ├── exp_mod_normal_cdf_log_4.stan │ │ │ │ │ ├── exp_mod_normal_log_1.stan │ │ │ │ │ ├── exp_mod_normal_log_2.stan │ │ │ │ │ ├── exp_mod_normal_log_3.stan │ │ │ │ │ └── exp_mod_normal_log_4.stan │ │ │ │ ├── exponential │ │ │ │ │ ├── exponential_cdf.stan │ │ │ │ │ ├── exponential_lccdf.stan │ │ │ │ │ ├── exponential_lcdf.stan │ │ │ │ │ └── exponential_lpdf.stan │ │ │ │ ├── frechet │ │ │ │ │ ├── frechet_cdf.stan │ │ │ │ │ ├── frechet_lccdf.stan │ │ │ │ │ ├── frechet_lcdf.stan │ │ │ │ │ └── frechet_lpdf.stan │ │ │ │ ├── gamma │ │ │ │ │ ├── gamma_cdf.stan │ │ │ │ │ ├── gamma_lccdf.stan │ │ │ │ │ ├── gamma_lcdf.stan │ │ │ │ │ └── gamma_lpdf.stan │ │ │ │ ├── gumbel │ │ │ │ │ ├── gumbel_cdf.stan │ │ │ │ │ ├── gumbel_lccdf.stan │ │ │ │ │ ├── gumbel_lcdf.stan │ │ │ │ │ └── gumbel_lpdf.stan │ │ │ │ ├── inv_chi_square │ │ │ │ │ ├── inv_chi_square_cdf.stan │ │ │ │ │ ├── inv_chi_square_lccdf.stan │ │ │ │ │ ├── inv_chi_square_lcdf.stan │ │ │ │ │ └── inv_chi_square_lpdf.stan │ │ │ │ ├── inv_gamma │ │ │ │ │ ├── inv_gamma_cdf.stan │ │ │ │ │ ├── inv_gamma_lccdf.stan │ │ │ │ │ ├── inv_gamma_lcdf.stan │ │ │ │ │ └── inv_gamma_lpdf.stan │ │ │ │ ├── logistic │ │ │ │ │ ├── logistic_cdf.stan │ │ │ │ │ ├── logistic_lccdf.stan │ │ │ │ │ ├── logistic_lcdf.stan │ │ │ │ │ └── logistic_lpdf.stan │ │ │ │ ├── loglogistic │ │ │ │ │ ├── loglogistic_cdf.stan │ │ │ │ │ └── loglogistic_lpdf.stan │ │ │ │ ├── lognormal │ │ │ │ │ ├── lognormal_cdf.stan │ │ │ │ │ ├── lognormal_lccdf.stan │ │ │ │ │ ├── lognormal_lcdf.stan │ │ │ │ │ └── lognormal_lpdf.stan │ │ │ │ ├── normal │ │ │ │ │ ├── normal_cdf.stan │ │ │ │ │ ├── normal_id_glm.stan │ │ │ │ │ ├── normal_lccdf.stan │ │ │ │ │ ├── normal_lcdf.stan │ │ │ │ │ └── normal_lpdf.stan │ │ │ │ ├── pareto │ │ │ │ │ ├── pareto_cdf.stan │ │ │ │ │ ├── pareto_lccdf.stan │ │ │ │ │ ├── pareto_lcdf.stan │ │ │ │ │ └── pareto_lpdf.stan │ │ │ │ ├── pareto_type_2 │ │ │ │ │ ├── pareto_type_2_ccdf_log_1.stan │ │ │ │ │ ├── pareto_type_2_ccdf_log_2.stan │ │ │ │ │ ├── pareto_type_2_ccdf_log_3.stan │ │ │ │ │ ├── pareto_type_2_ccdf_log_4.stan │ │ │ │ │ ├── pareto_type_2_cdf_1.stan │ │ │ │ │ ├── pareto_type_2_cdf_2.stan │ │ │ │ │ ├── pareto_type_2_cdf_3.stan │ │ │ │ │ ├── pareto_type_2_cdf_4.stan │ │ │ │ │ ├── pareto_type_2_cdf_log_1.stan │ │ │ │ │ ├── pareto_type_2_cdf_log_2.stan │ │ │ │ │ ├── pareto_type_2_cdf_log_3.stan │ │ │ │ │ ├── pareto_type_2_cdf_log_4.stan │ │ │ │ │ ├── pareto_type_2_log_1.stan │ │ │ │ │ ├── pareto_type_2_log_2.stan │ │ │ │ │ ├── pareto_type_2_log_3.stan │ │ │ │ │ └── pareto_type_2_log_4.stan │ │ │ │ ├── rayleigh │ │ │ │ │ ├── rayleigh_cdf.stan │ │ │ │ │ ├── rayleigh_lccdf.stan │ │ │ │ │ ├── rayleigh_lcdf.stan │ │ │ │ │ └── rayleigh_lpdf.stan │ │ │ │ ├── scaled_inv_chi_square │ │ │ │ │ ├── scaled_inv_chi_square_cdf.stan │ │ │ │ │ ├── scaled_inv_chi_square_lccdf.stan │ │ │ │ │ ├── scaled_inv_chi_square_lcdf.stan │ │ │ │ │ └── scaled_inv_chi_square_lpdf.stan │ │ │ │ ├── skew_double_exponential │ │ │ │ │ ├── skew_double_exponential_ccdf_log_1.stan │ │ │ │ │ ├── skew_double_exponential_ccdf_log_2.stan │ │ │ │ │ ├── skew_double_exponential_ccdf_log_3.stan │ │ │ │ │ ├── skew_double_exponential_ccdf_log_4.stan │ │ │ │ │ ├── skew_double_exponential_cdf_1.stan │ │ │ │ │ ├── skew_double_exponential_cdf_2.stan │ │ │ │ │ ├── skew_double_exponential_cdf_3.stan │ │ │ │ │ ├── skew_double_exponential_cdf_4.stan │ │ │ │ │ ├── skew_double_exponential_cdf_log_1.stan │ │ │ │ │ ├── skew_double_exponential_cdf_log_2.stan │ │ │ │ │ ├── skew_double_exponential_cdf_log_3.stan │ │ │ │ │ ├── skew_double_exponential_cdf_log_4.stan │ │ │ │ │ ├── skew_double_exponential_log_1.stan │ │ │ │ │ ├── skew_double_exponential_log_2.stan │ │ │ │ │ ├── skew_double_exponential_log_3.stan │ │ │ │ │ └── skew_double_exponential_log_4.stan │ │ │ │ ├── skew_normal │ │ │ │ │ ├── skew_normal_ccdf_log_1.stan │ │ │ │ │ ├── skew_normal_ccdf_log_2.stan │ │ │ │ │ ├── skew_normal_ccdf_log_3.stan │ │ │ │ │ ├── skew_normal_ccdf_log_4.stan │ │ │ │ │ ├── skew_normal_cdf_1.stan │ │ │ │ │ ├── skew_normal_cdf_2.stan │ │ │ │ │ ├── skew_normal_cdf_3.stan │ │ │ │ │ ├── skew_normal_cdf_4.stan │ │ │ │ │ ├── skew_normal_cdf_log_1.stan │ │ │ │ │ ├── skew_normal_cdf_log_2.stan │ │ │ │ │ ├── skew_normal_cdf_log_3.stan │ │ │ │ │ ├── skew_normal_cdf_log_4.stan │ │ │ │ │ ├── skew_normal_log_1.stan │ │ │ │ │ ├── skew_normal_log_2.stan │ │ │ │ │ ├── skew_normal_log_3.stan │ │ │ │ │ └── skew_normal_log_4.stan │ │ │ │ ├── std_normal │ │ │ │ │ ├── std_normal_cdf.stan │ │ │ │ │ ├── std_normal_lccdf.stan │ │ │ │ │ ├── std_normal_lcdf.stan │ │ │ │ │ └── std_normal_lpdf.stan │ │ │ │ ├── student_t │ │ │ │ │ ├── student_t_ccdf_log_1.stan │ │ │ │ │ ├── student_t_ccdf_log_2.stan │ │ │ │ │ ├── student_t_ccdf_log_3.stan │ │ │ │ │ ├── student_t_ccdf_log_4.stan │ │ │ │ │ ├── student_t_cdf_1.stan │ │ │ │ │ ├── student_t_cdf_2.stan │ │ │ │ │ ├── student_t_cdf_3.stan │ │ │ │ │ ├── student_t_cdf_4.stan │ │ │ │ │ ├── student_t_cdf_log_1.stan │ │ │ │ │ ├── student_t_cdf_log_2.stan │ │ │ │ │ ├── student_t_cdf_log_3.stan │ │ │ │ │ ├── student_t_cdf_log_4.stan │ │ │ │ │ ├── student_t_log_1.stan │ │ │ │ │ ├── student_t_log_2.stan │ │ │ │ │ ├── student_t_log_3.stan │ │ │ │ │ └── student_t_log_4.stan │ │ │ │ ├── uniform │ │ │ │ │ ├── uniform_cdf.stan │ │ │ │ │ ├── uniform_lccdf.stan │ │ │ │ │ ├── uniform_lcdf.stan │ │ │ │ │ └── uniform_lpdf.stan │ │ │ │ ├── von_mises │ │ │ │ │ ├── von_mises_cdf.stan │ │ │ │ │ ├── von_mises_lccdf.stan │ │ │ │ │ ├── von_mises_lcdf.stan │ │ │ │ │ └── von_mises_lpdf.stan │ │ │ │ ├── weibull │ │ │ │ │ ├── weibull_cdf.stan │ │ │ │ │ ├── weibull_lccdf.stan │ │ │ │ │ ├── weibull_lcdf.stan │ │ │ │ │ └── weibull_lpdf.stan │ │ │ │ └── wiener │ │ │ │ │ ├── wiener_5_args.stan │ │ │ │ │ ├── wiener_5_args_vec.stan │ │ │ │ │ ├── wiener_full_lpdf_0.stan │ │ │ │ │ ├── wiener_full_lpdf_1.stan │ │ │ │ │ ├── wiener_full_lpdf_2.stan │ │ │ │ │ ├── wiener_full_lpdf_3.stan │ │ │ │ │ ├── wiener_full_lpdf_4.stan │ │ │ │ │ ├── wiener_full_lpdf_5.stan │ │ │ │ │ ├── wiener_full_lpdf_6.stan │ │ │ │ │ ├── wiener_full_lpdf_vec_1.stan │ │ │ │ │ ├── wiener_full_lpdf_vec_2.stan │ │ │ │ │ ├── wiener_log_0.stan │ │ │ │ │ ├── wiener_log_1.stan │ │ │ │ │ ├── wiener_log_10.stan │ │ │ │ │ ├── wiener_log_11.stan │ │ │ │ │ ├── wiener_log_12.stan │ │ │ │ │ ├── wiener_log_13.stan │ │ │ │ │ ├── wiener_log_14.stan │ │ │ │ │ ├── wiener_log_15.stan │ │ │ │ │ ├── wiener_log_16.stan │ │ │ │ │ ├── wiener_log_17.stan │ │ │ │ │ ├── wiener_log_18.stan │ │ │ │ │ ├── wiener_log_19.stan │ │ │ │ │ ├── wiener_log_2.stan │ │ │ │ │ ├── wiener_log_20.stan │ │ │ │ │ ├── wiener_log_21.stan │ │ │ │ │ ├── wiener_log_22.stan │ │ │ │ │ ├── wiener_log_23.stan │ │ │ │ │ ├── wiener_log_24.stan │ │ │ │ │ ├── wiener_log_25.stan │ │ │ │ │ ├── wiener_log_26.stan │ │ │ │ │ ├── wiener_log_27.stan │ │ │ │ │ ├── wiener_log_28.stan │ │ │ │ │ ├── wiener_log_29.stan │ │ │ │ │ ├── wiener_log_3.stan │ │ │ │ │ ├── wiener_log_30.stan │ │ │ │ │ ├── wiener_log_31.stan │ │ │ │ │ ├── wiener_log_32.stan │ │ │ │ │ ├── wiener_log_33.stan │ │ │ │ │ ├── wiener_log_34.stan │ │ │ │ │ ├── wiener_log_35.stan │ │ │ │ │ ├── wiener_log_36.stan │ │ │ │ │ ├── wiener_log_37.stan │ │ │ │ │ ├── wiener_log_38.stan │ │ │ │ │ ├── wiener_log_39.stan │ │ │ │ │ ├── wiener_log_4.stan │ │ │ │ │ ├── wiener_log_40.stan │ │ │ │ │ ├── wiener_log_41.stan │ │ │ │ │ ├── wiener_log_5.stan │ │ │ │ │ ├── wiener_log_6.stan │ │ │ │ │ ├── wiener_log_7.stan │ │ │ │ │ ├── wiener_log_8.stan │ │ │ │ │ └── wiener_log_9.stan │ │ │ │ └── discrete │ │ │ │ ├── bernoulli │ │ │ │ ├── bernoulli_cdf.stan │ │ │ │ ├── bernoulli_lccdf.stan │ │ │ │ ├── bernoulli_lcdf.stan │ │ │ │ ├── bernoulli_logit_glm.stan │ │ │ │ ├── bernoulli_logit_lpmf.stan │ │ │ │ └── bernoulli_lpmf.stan │ │ │ │ ├── beta_binomial │ │ │ │ ├── beta_binomial_cdf.stan │ │ │ │ ├── beta_binomial_lccdf.stan │ │ │ │ ├── beta_binomial_lcdf.stan │ │ │ │ └── beta_binomial_lpmf.stan │ │ │ │ ├── beta_neg_binomial │ │ │ │ ├── beta_neg_binomial_cdf.stan │ │ │ │ ├── beta_neg_binomial_lccdf.stan │ │ │ │ ├── beta_neg_binomial_lcdf.stan │ │ │ │ └── beta_neg_binomial_lpmf.stan │ │ │ │ ├── binomial │ │ │ │ ├── binomial_cdf.stan │ │ │ │ ├── binomial_lccdf.stan │ │ │ │ ├── binomial_lcdf.stan │ │ │ │ ├── binomial_logit_glm.stan │ │ │ │ └── binomial_lpmf.stan │ │ │ │ ├── discrete_range │ │ │ │ ├── discrete_range_cdf.stan │ │ │ │ ├── discrete_range_lccdf.stan │ │ │ │ ├── discrete_range_lcdf.stan │ │ │ │ └── discrete_range_lpmf.stan │ │ │ │ ├── hypergeometric │ │ │ │ └── hypergeometric_log.stan │ │ │ │ ├── neg_binomial │ │ │ │ ├── neg_binomial_cdf.stan │ │ │ │ ├── neg_binomial_lccdf.stan │ │ │ │ ├── neg_binomial_lcdf.stan │ │ │ │ └── neg_binomial_lpmf.stan │ │ │ │ ├── neg_binomial_2 │ │ │ │ ├── neg_binomial_2_log_glm.stan │ │ │ │ ├── neg_binomial_2_log_lpmf.stan │ │ │ │ ├── neg_binomial_2_lpmf.stan │ │ │ │ ├── neg_binomial_cdf.stan │ │ │ │ ├── neg_binomial_lccdf.stan │ │ │ │ └── neg_binomial_lcdf.stan │ │ │ │ └── poisson │ │ │ │ ├── poisson_cdf.stan │ │ │ │ ├── poisson_lccdf.stan │ │ │ │ ├── poisson_lcdf.stan │ │ │ │ ├── poisson_log_glm.stan │ │ │ │ ├── poisson_log_lpmf.stan │ │ │ │ └── poisson_lpmf.stan │ │ └── math │ │ │ ├── functions │ │ │ ├── abs.stan │ │ │ ├── acos.stan │ │ │ ├── acosh.stan │ │ │ ├── asin.stan │ │ │ ├── asinh.stan │ │ │ ├── atan.stan │ │ │ ├── atan2.stan │ │ │ ├── atanh.stan │ │ │ ├── bessel_first_kind.stan │ │ │ ├── bessel_second_kind.stan │ │ │ ├── binary_log_loss.stan │ │ │ ├── cbrt.stan │ │ │ ├── ceil.stan │ │ │ ├── choose.stan │ │ │ ├── constants.stan │ │ │ ├── cos.stan │ │ │ ├── cosh.stan │ │ │ ├── digamma.stan │ │ │ ├── erf.stan │ │ │ ├── erfc.stan │ │ │ ├── exp.stan │ │ │ ├── exp2.stan │ │ │ ├── expm1.stan │ │ │ ├── fabs.stan │ │ │ ├── falling_factorial.stan │ │ │ ├── fdim.stan │ │ │ ├── floor.stan │ │ │ ├── fma.stan │ │ │ ├── fmax.stan │ │ │ ├── fmin.stan │ │ │ ├── fmod.stan │ │ │ ├── gamma_p.stan │ │ │ ├── gamma_q.stan │ │ │ ├── get_imag.stan │ │ │ ├── get_real.stan │ │ │ ├── hmm_hidden_states_prob.stan │ │ │ ├── hypergeometric_1F0.stan │ │ │ ├── hypergeometric_2F1.stan │ │ │ ├── hypergeometric_3F2.stan │ │ │ ├── hypergeometric_pFq.stan │ │ │ ├── hypot.stan │ │ │ ├── inc_beta.stan │ │ │ ├── int_step.stan │ │ │ ├── integrate_1d.stan │ │ │ ├── inv.stan │ │ │ ├── inv_cloglog.stan │ │ │ ├── inv_erfc.stan │ │ │ ├── inv_inc_beta.stan │ │ │ ├── inv_logit.stan │ │ │ ├── inv_sqrt.stan │ │ │ ├── inv_square.stan │ │ │ ├── is_inf.stan │ │ │ ├── is_nan.stan │ │ │ ├── lambert.stan │ │ │ ├── lbeta.stan │ │ │ ├── lgamma.stan │ │ │ ├── lmgamma.stan │ │ │ ├── log.stan │ │ │ ├── log10.stan │ │ │ ├── log1m.stan │ │ │ ├── log1m_exp.stan │ │ │ ├── log1m_inv_logit.stan │ │ │ ├── log1p.stan │ │ │ ├── log1p_exp.stan │ │ │ ├── log2.stan │ │ │ ├── log_diff_exp.stan │ │ │ ├── log_falling_factorial.stan │ │ │ ├── log_inv_logit.stan │ │ │ ├── log_mix.stan │ │ │ ├── log_rising_factorial.stan │ │ │ ├── log_sum_exp.stan │ │ │ ├── logit.stan │ │ │ ├── max.stan │ │ │ ├── min.stan │ │ │ ├── modified_bessel_first_kind.stan │ │ │ ├── modified_bessel_second_kind.stan │ │ │ ├── norm1.stan │ │ │ ├── norm2.stan │ │ │ ├── operators_int.stan │ │ │ ├── operators_real.stan │ │ │ ├── owens_t.stan │ │ │ ├── phi.stan │ │ │ ├── phi_approx.stan │ │ │ ├── pow.stan │ │ │ ├── quantile.stan │ │ │ ├── rising_factorial.stan │ │ │ ├── round.stan │ │ │ ├── sin.stan │ │ │ ├── sinh.stan │ │ │ ├── special_values.stan │ │ │ ├── sqrt.stan │ │ │ ├── square.stan │ │ │ ├── step.stan │ │ │ ├── tan.stan │ │ │ ├── tanh.stan │ │ │ ├── tgamma.stan │ │ │ ├── to_complex.stan │ │ │ ├── to_int.stan │ │ │ ├── trigamma.stan │ │ │ └── trunc.stan │ │ │ ├── if_else.stan │ │ │ ├── matrix │ │ │ ├── Phi.stan │ │ │ ├── Phi_approx.stan │ │ │ ├── abs.stan │ │ │ ├── acos.stan │ │ │ ├── acosh.stan │ │ │ ├── add_diag.stan │ │ │ ├── append_array.stan │ │ │ ├── append_col.stan │ │ │ ├── append_row.stan │ │ │ ├── asin.stan │ │ │ ├── asinh.stan │ │ │ ├── atan.stan │ │ │ ├── atanh.stan │ │ │ ├── bessel_first_kind.stan │ │ │ ├── bessel_second_kind.stan │ │ │ ├── beta.stan │ │ │ ├── binary_log_loss.stan │ │ │ ├── block.stan │ │ │ ├── broadcast_infix_operators.stan │ │ │ ├── cbrt.stan │ │ │ ├── ceil.stan │ │ │ ├── chol2inv.stan │ │ │ ├── cholesky_decompose.stan │ │ │ ├── choose.stan │ │ │ ├── col.stan │ │ │ ├── cols.stan │ │ │ ├── columns_dot_product.stan │ │ │ ├── columns_dot_self.stan │ │ │ ├── complex_schur_decompose.stan │ │ │ ├── conj.stan │ │ │ ├── container_construction_utilities.stan │ │ │ ├── cos.stan │ │ │ ├── cosh.stan │ │ │ ├── crossprod.stan │ │ │ ├── csr_extract.stan │ │ │ ├── csr_extract_u.stan │ │ │ ├── csr_extract_v.stan │ │ │ ├── csr_extract_w.stan │ │ │ ├── csr_matrix_times_vector.stan │ │ │ ├── csr_to_dense_matrix.stan │ │ │ ├── cumulative_sum.stan │ │ │ ├── determinant.stan │ │ │ ├── diag_matrix.stan │ │ │ ├── diag_post_multiply.stan │ │ │ ├── diag_pre_multiply.stan │ │ │ ├── diagonal.stan │ │ │ ├── digamma.stan │ │ │ ├── dims.stan │ │ │ ├── distance.stan │ │ │ ├── dot_product.stan │ │ │ ├── dot_self.stan │ │ │ ├── eigendecompose.stan │ │ │ ├── eigendecompose_sym.stan │ │ │ ├── eigenvalues.stan │ │ │ ├── eigenvalues_sym.stan │ │ │ ├── eigenvectors.stan │ │ │ ├── eigenvectors_sym.stan │ │ │ ├── elementwise_pow.stan │ │ │ ├── elementwise_products.stan │ │ │ ├── erf.stan │ │ │ ├── erfc.stan │ │ │ ├── exp.stan │ │ │ ├── exp2.stan │ │ │ ├── expm1.stan │ │ │ ├── falling_factorial.stan │ │ │ ├── fdim.stan │ │ │ ├── fft.stan │ │ │ ├── floor.stan │ │ │ ├── fmax.stan │ │ │ ├── fmin.stan │ │ │ ├── fmod.stan │ │ │ ├── gamma_p.stan │ │ │ ├── gamma_q.stan │ │ │ ├── generalized_inverse.stan │ │ │ ├── get_imag.stan │ │ │ ├── get_real.stan │ │ │ ├── gp_regression.stan │ │ │ ├── head.stan │ │ │ ├── hypot.stan │ │ │ ├── infix_matrix_operators.stan │ │ │ ├── inv.stan │ │ │ ├── inv_Phi.stan │ │ │ ├── inv_cloglog.stan │ │ │ ├── inv_erfc.stan │ │ │ ├── inv_fft.stan │ │ │ ├── inv_logit.stan │ │ │ ├── inv_sqrt.stan │ │ │ ├── inv_square.stan │ │ │ ├── inverse.stan │ │ │ ├── inverse_spd.stan │ │ │ ├── lambert.stan │ │ │ ├── lbeta.stan │ │ │ ├── lchoose.stan │ │ │ ├── ldexp.stan │ │ │ ├── lgamma.stan │ │ │ ├── lmgamma.stan │ │ │ ├── lmultiply.stan │ │ │ ├── log.stan │ │ │ ├── log10.stan │ │ │ ├── log1m.stan │ │ │ ├── log1m_exp.stan │ │ │ ├── log1m_inv_logit.stan │ │ │ ├── log1p.stan │ │ │ ├── log1p_exp.stan │ │ │ ├── log2.stan │ │ │ ├── log_determinant.stan │ │ │ ├── log_determinant_spd.stan │ │ │ ├── log_diff_exp.stan │ │ │ ├── log_falling_factorial.stan │ │ │ ├── log_inv_logit.stan │ │ │ ├── log_inv_logit_diff.stan │ │ │ ├── log_modified_bessel_first_kind.stan │ │ │ ├── log_rising_factorial.stan │ │ │ ├── log_softmax.stan │ │ │ ├── log_sum_exp.stan │ │ │ ├── logit.stan │ │ │ ├── matrix_division.stan │ │ │ ├── matrix_exp.stan │ │ │ ├── matrix_exp_multiply.stan │ │ │ ├── matrix_power.stan │ │ │ ├── max.stan │ │ │ ├── mdivide_left.stan │ │ │ ├── mdivide_left_spd.stan │ │ │ ├── mdivide_left_tri_low.stan │ │ │ ├── mdivide_right.stan │ │ │ ├── mdivide_right_spd.stan │ │ │ ├── mdivide_right_tri_low.stan │ │ │ ├── mean.stan │ │ │ ├── min.stan │ │ │ ├── minus.stan │ │ │ ├── modified_bessel_first_kind.stan │ │ │ ├── modified_bessel_second_kind.stan │ │ │ ├── multiply_lower_tri_self_transpose.stan │ │ │ ├── negation.stan │ │ │ ├── num_elements.stan │ │ │ ├── owens_t.stan │ │ │ ├── pow.stan │ │ │ ├── prod.stan │ │ │ ├── qr.stan │ │ │ ├── qr_Q.stan │ │ │ ├── qr_R.stan │ │ │ ├── qr_thin.stan │ │ │ ├── qr_thin_Q.stan │ │ │ ├── qr_thin_R.stan │ │ │ ├── quad_form.stan │ │ │ ├── quad_form_diag.stan │ │ │ ├── quad_form_sym.stan │ │ │ ├── rank.stan │ │ │ ├── rep_matrix.stan │ │ │ ├── rep_param.stan │ │ │ ├── rep_row_vector.stan │ │ │ ├── rep_vector.stan │ │ │ ├── reverse.stan │ │ │ ├── rising_factorial.stan │ │ │ ├── round.stan │ │ │ ├── row.stan │ │ │ ├── rows.stan │ │ │ ├── rows_dot_product.stan │ │ │ ├── rows_dot_self.stan │ │ │ ├── scale_matrix_exp_multiply.stan │ │ │ ├── sd.stan │ │ │ ├── segment.stan │ │ │ ├── sin.stan │ │ │ ├── singular_values.stan │ │ │ ├── sinh.stan │ │ │ ├── size.stan │ │ │ ├── softmax.stan │ │ │ ├── sort_asc.stan │ │ │ ├── sort_desc.stan │ │ │ ├── sort_indices_asc.stan │ │ │ ├── sort_indices_desc.stan │ │ │ ├── sqrt.stan │ │ │ ├── square.stan │ │ │ ├── squared_distance.stan │ │ │ ├── std_normal_log_qf.stan │ │ │ ├── std_normal_qf.stan │ │ │ ├── sub_col.stan │ │ │ ├── sub_row.stan │ │ │ ├── sum.stan │ │ │ ├── svd.stan │ │ │ ├── svd_U.stan │ │ │ ├── svd_V.stan │ │ │ ├── symmetrize_from_lower_tri.stan │ │ │ ├── tail.stan │ │ │ ├── tan.stan │ │ │ ├── tanh.stan │ │ │ ├── tcrossprod.stan │ │ │ ├── tgamma.stan │ │ │ ├── to_array_1d.stan │ │ │ ├── to_array_2d.stan │ │ │ ├── to_complex.stan │ │ │ ├── to_matrix.stan │ │ │ ├── to_row_vector.stan │ │ │ ├── to_vector.stan │ │ │ ├── trace.stan │ │ │ ├── trace_gen_quad_form.stan │ │ │ ├── trace_quad_form.stan │ │ │ ├── transpose.stan │ │ │ ├── trigamma.stan │ │ │ ├── trunc.stan │ │ │ └── variance.stan │ │ │ ├── operators │ │ │ ├── and.stan │ │ │ ├── and_or_interaction.stan │ │ │ ├── equal.stan │ │ │ ├── greater_than.stan │ │ │ ├── greater_than_or_equal.stan │ │ │ ├── less_than.stan │ │ │ ├── less_than_or_equal.stan │ │ │ ├── not.stan │ │ │ ├── not_equal.stan │ │ │ └── or.stan │ │ │ ├── transforms │ │ │ ├── cholesky_factor_corr_constrain.stan │ │ │ ├── cholesky_factor_corr_jacobian.stan │ │ │ ├── cholesky_factor_corr_unconstrain.stan │ │ │ ├── cholesky_factor_cov_constrain.stan │ │ │ ├── cholesky_factor_cov_jacobian.stan │ │ │ ├── cholesky_factor_cov_unconstrain.stan │ │ │ ├── corr_matrix_constrain.stan │ │ │ ├── corr_matrix_jacobian.stan │ │ │ ├── corr_matrix_unconstrain.stan │ │ │ ├── cov_matrix_constrain.stan │ │ │ ├── cov_matrix_jacobian.stan │ │ │ ├── cov_matrix_unconstrain.stan │ │ │ ├── lower_bound_constrain.stan │ │ │ ├── lower_bound_jacobian.stan │ │ │ ├── lower_bound_unconstrain.stan │ │ │ ├── lower_upper_bound_constrain.stan │ │ │ ├── lower_upper_bound_jacobian.stan │ │ │ ├── lower_upper_bound_unconstrain.stan │ │ │ ├── offset_multiplier_constrain.stan │ │ │ ├── offset_multiplier_jacobian.stan │ │ │ ├── offset_multiplier_unconstrain.stan │ │ │ ├── ordered_constrain.stan │ │ │ ├── ordered_jacobian.stan │ │ │ ├── ordered_unconstrain.stan │ │ │ ├── positive_ordered_constrain.stan │ │ │ ├── positive_ordered_jacobian.stan │ │ │ ├── positive_ordered_unconstrain.stan │ │ │ ├── simplex_constrain.stan │ │ │ ├── simplex_jacobian.stan │ │ │ ├── simplex_unconstrain.stan │ │ │ ├── stochastic_column_constrain.stan │ │ │ ├── stochastic_column_jacobian.stan │ │ │ ├── stochastic_column_unconstrain.stan │ │ │ ├── stochastic_row_constrain.stan │ │ │ ├── stochastic_row_jacobian.stan │ │ │ ├── stochastic_row_unconstrain.stan │ │ │ ├── sum_to_zero_constrain.stan │ │ │ ├── sum_to_zero_jacobian.stan │ │ │ ├── sum_to_zero_unconstrain.stan │ │ │ ├── unit_vector_constrain.stan │ │ │ ├── unit_vector_jacobian.stan │ │ │ ├── unit_vector_unconstrain.stan │ │ │ ├── upper_bound_constrain.stan │ │ │ ├── upper_bound_jacobian.stan │ │ │ └── upper_bound_unconstrain.stan │ │ │ └── while.stan │ ├── functions-good-void.stan │ ├── functions-good1.stan │ ├── functions-good2.stan │ ├── functions-good3.stan │ ├── functions-promote-return.stan │ ├── funs1.stan │ ├── funs2.stan │ ├── funs3.stan │ ├── funs4.stan │ ├── funs5.stan │ ├── funs6.stan │ ├── funs7.stan │ ├── genquant-data-only.stan │ ├── good_fundef_returntypes1.stan │ ├── good_fundef_returntypes2.stan │ ├── good_fundef_returntypes3.stan │ ├── good_fundef_returntypes4.stan │ ├── good_inf.stan │ ├── if-else-formatting.stan │ ├── illegal_generated_quantities.stan │ ├── illegal_transformed_data.stan │ ├── illegal_transformed_parameters.stan │ ├── increment-target.stan │ ├── indexing │ │ ├── dune │ │ ├── good-empty-omni.stan │ │ ├── good-ints.stan │ │ ├── good-lb.stan │ │ ├── good-lub.stan │ │ ├── good-omni.stan │ │ ├── good-omni2.stan │ │ ├── good-omni3.stan │ │ ├── good-ub.stan │ │ └── pretty.expected │ ├── infinite_loop_return.stan │ ├── int_fun.stan │ ├── int_overloads.stan │ ├── io_example.stan │ ├── keywords-else-if.stan │ ├── keywords-else.stan │ ├── keywords-for.stan │ ├── keywords-if.stan │ ├── keywords-increment-log-prob.stan │ ├── keywords-integrate-ode.stan │ ├── keywords-print.stan │ ├── keywords-reject.stan │ ├── keywords-return.stan │ ├── keywords-while.stan │ ├── lang │ │ ├── dune │ │ ├── exit_model.stan │ │ ├── good_const.stan │ │ ├── good_cov.stan │ │ ├── good_fun_name.stan │ │ ├── good_funs.stan │ │ ├── good_intercept_var.stan │ │ ├── good_local_var_array_size.stan │ │ ├── good_matrix_ops.stan │ │ ├── good_nested_decl.stan │ │ ├── good_semicolons.stan │ │ ├── good_trunc.stan │ │ ├── good_vars.stan │ │ ├── good_vec_constraints.stan │ │ ├── pretty.expected │ │ ├── print_reject_function_gq.stan │ │ ├── print_reject_function_model.stan │ │ ├── print_reject_function_tdata.stan │ │ ├── print_reject_function_tparams.stan │ │ ├── print_reject_gq_block.stan │ │ ├── print_reject_model_block.stan │ │ ├── print_reject_tdata_block.stan │ │ ├── print_reject_tparams_block.stan │ │ ├── reject_func_call_generated_quantities.stan │ │ ├── reject_func_call_model.stan │ │ ├── reject_func_call_transformed_data.stan │ │ ├── reject_func_call_transformed_parameters.stan │ │ ├── reject_generated_quantities.stan │ │ ├── reject_model.stan │ │ ├── reject_mult_args.stan │ │ ├── reject_transformed_data.stan │ │ ├── reject_transformed_parameters.stan │ │ └── test_lp.stan │ ├── laplace_deriv_check.stan │ ├── logistic_regression_reg_horseshoe.stan │ ├── long_functions.stan │ ├── lower-trunc-discrete.stan │ ├── lp_in_fun.stan │ ├── lp_transformed_param.stan │ ├── map_rect.stan │ ├── mat_assign.stan │ ├── mcmc │ │ ├── dune │ │ ├── hmc │ │ │ ├── common │ │ │ │ ├── dune │ │ │ │ ├── gauss.stan │ │ │ │ ├── gauss3D.stan │ │ │ │ └── pretty.expected │ │ │ ├── dune │ │ │ ├── hamiltonians │ │ │ │ ├── dune │ │ │ │ ├── funnel.stan │ │ │ │ └── pretty.expected │ │ │ ├── integrators │ │ │ │ ├── command.stan │ │ │ │ ├── dune │ │ │ │ ├── gauss.stan │ │ │ │ └── pretty.expected │ │ │ └── pretty.expected │ │ └── pretty.expected │ ├── min-max-types.stan │ ├── model │ │ ├── domain_fail.stan │ │ ├── dune │ │ ├── pretty.expected │ │ └── valid.stan │ ├── model2.stan │ ├── model_block_empty.stan │ ├── multiple_funs.stan │ ├── neg_binomial_2_log_glm_old_performance.stan │ ├── neg_binomial_2_log_glm_performance.stan │ ├── new-prob-fun-suffixes.stan │ ├── normal_id_glm_old_performance.stan │ ├── normal_id_glm_performance.stan │ ├── numeric-literal.stan │ ├── ode-int-segments.stan │ ├── ode-nested-quotes.stan │ ├── ode │ │ ├── dune │ │ ├── ode_adams_test_model.stan │ │ ├── ode_adams_tol_test_model.stan │ │ ├── ode_adjoint_test_model.stan │ │ ├── ode_bdf_test_model.stan │ │ ├── ode_bdf_tol_test_model.stan │ │ ├── ode_ckrk_test_model.stan │ │ ├── ode_ckrk_tol_test_model.stan │ │ ├── ode_rk45_test_model.stan │ │ ├── ode_rk45_tol_test_model.stan │ │ └── pretty.expected │ ├── ode_good.stan │ ├── optimization │ │ ├── dune │ │ ├── exponential_boundary.stan │ │ ├── pretty.expected │ │ └── rosenbrock.stan │ ├── overloading │ │ ├── dae_overloaded.stan │ │ ├── dune │ │ ├── is_real.stan │ │ ├── minimum_promotion.stan │ │ ├── multi_fun.stan │ │ ├── num_args.stan │ │ ├── pretty.expected │ │ ├── redefine-prob1.stan │ │ ├── reduce_sum_multiple.stan │ │ ├── reduce_sum_ordering.stan │ │ ├── sir_overloaded_odes.stan │ │ ├── stan_math.stan │ │ └── tilde_resolve.stan │ ├── parser-generator │ │ ├── algebra_solver.stan │ │ ├── cholesky_cov_data_block.stan │ │ ├── cholesky_cov_gqs_block.stan │ │ ├── cholesky_cov_param_block.stan │ │ ├── cholesky_cov_transform_data_block.stan │ │ ├── cholesky_cov_transform_param_block.stan │ │ ├── data_qualifier_scope_xformed_data.stan │ │ ├── deep-copy-warning.stan │ │ ├── dune │ │ ├── function_var.stan │ │ ├── function_var_array_syntax.stan │ │ ├── local_var_function_body.stan │ │ ├── local_var_gqs.stan │ │ ├── local_var_transformed_data_block.stan │ │ ├── local_var_transformed_param_block.stan │ │ ├── multidim_var_all_ar45_mat23.stan │ │ ├── multidim_var_data_ar45_mat23.stan │ │ ├── multidim_var_gen_qs_ar45_mat23.stan │ │ ├── multidim_var_param_ar45_mat23.stan │ │ ├── multidim_var_transform_data_ar45_mat23.stan │ │ ├── multidim_var_transform_param_ar45_mat23.stan │ │ ├── ode.stan │ │ ├── ode_control.stan │ │ ├── pretty.expected │ │ ├── prim_var_data_block.stan │ │ ├── prim_var_gqs.stan │ │ ├── prim_var_param_block.stan │ │ ├── prim_var_transformed_data_block.stan │ │ ├── prim_var_transformed_param_block.stan │ │ ├── row_vector_expr_terms.stan │ │ ├── test_transform_inits.stan │ │ └── user-function-struct-const.stan │ ├── poisson_log_glm_old_performance.stan │ ├── poisson_log_glm_performance.stan │ ├── pretty.expected │ ├── print_chars.stan │ ├── print_indexing.stan │ ├── profiling.stan │ ├── promotion │ │ ├── array_overloaded.stan │ │ ├── array_promotion.stan │ │ ├── complex_functions.stan │ │ ├── dune │ │ ├── newton_x_r_type.stan │ │ ├── newton_x_r_type_control.stan │ │ ├── pretty.expected │ │ ├── propto.stan │ │ ├── return_position.stan │ │ ├── tilde_syntax.stan │ │ ├── x_r_type.stan │ │ └── x_r_type_control.stan │ ├── propto-good.stan │ ├── recursive-functions.stan │ ├── rng_loc.stan │ ├── rng_transformed_data.stan │ ├── runtime_errors │ │ ├── dune │ │ ├── pretty.expected │ │ ├── size_mismatch_data.stan │ │ ├── size_mismatch_fun.stan │ │ ├── size_mismatch_gq.stan │ │ ├── size_mismatch_gq2.stan │ │ ├── size_mismatch_lp_local.stan │ │ └── size_mismatch_tparam.stan │ ├── services │ │ ├── bym2_offset_only.stan │ │ ├── dune │ │ ├── pretty.expected │ │ ├── test_gq.stan │ │ ├── test_gq2.stan │ │ └── test_lp.stan │ ├── single-arg-conddist.stan │ ├── solve_newton_good.stan │ ├── solve_powell_good.stan │ ├── stanc_helper.stan │ ├── stat_comp_benchmarks_models │ │ ├── arK.stan │ │ ├── arma.stan │ │ ├── dune │ │ ├── eight_schools.stan │ │ ├── garch.stan │ │ ├── gen_gp_data.stan │ │ ├── gp_pois_regr.stan │ │ ├── gp_regr.stan │ │ ├── irt_2pl.stan │ │ ├── low_dim_corr_gauss.stan │ │ ├── low_dim_gauss_mix.stan │ │ ├── low_dim_gauss_mix_collapse.stan │ │ ├── one_comp_mm_elim_abs.stan │ │ ├── pretty.expected │ │ ├── sim_one_comp_mm_elim_abs.stan │ │ └── sir.stan │ ├── target.stan │ ├── target_good.stan │ ├── tern_op_contains_var.stan │ ├── to_matrix_exp.stan │ ├── truncation-user-defined.stan │ ├── truncation-wild.stan │ ├── tuples │ │ ├── arrays-tuples-nested.stan │ │ ├── basic_unpacking.stan │ │ ├── cpp.expected │ │ ├── dune │ │ ├── infer_tuple_ad.stan │ │ ├── nested_unpacking.stan │ │ ├── overloading.stan │ │ ├── pretty.expected │ │ ├── qr_unpack.stan │ │ ├── reconstruct.stan │ │ ├── simple.stan │ │ ├── simple2.stan │ │ ├── simple3.stan │ │ ├── transformed_mir.expected │ │ ├── tuple-constraints-data.stan │ │ ├── tuple-constraints-params.stan │ │ ├── tuple-dataonly.stan │ │ ├── tuple-dataonly2.stan │ │ ├── tuple-foreach.stan │ │ ├── tuple-full.stan │ │ ├── tuple-ix-assign.stan │ │ ├── tuple-ix-assign2.stan │ │ ├── tuple-ix-assign3.stan │ │ ├── tuple-ix-assign4.stan │ │ ├── tuple-nested-param.stan │ │ ├── tuple-params.stan │ │ ├── tuple-promotion.stan │ │ ├── tuple-templating.stan │ │ ├── tuple_copying.stan │ │ ├── tuple_exprs.stan │ │ ├── tuple_hof.stan │ │ ├── tuple_lpdf.stan │ │ ├── tuple_lpdf2.stan │ │ ├── tuple_lpmf.stan │ │ ├── tuple_temporary.stan │ │ └── unpack_promote.stan │ ├── unconstrained_params_var.stan │ ├── unnormalized_math_fun_lpdf.stan │ ├── unnormalized_math_fun_lpmf.stan │ ├── user-defined-lpdf-fun.stan │ ├── user-distro-truncate.stan │ ├── validate_add_expression_dimss_good.stan │ ├── validate_add_var_good.stan │ ├── validate_bounds_comparison.stan │ ├── validate_conditional_op_good.stan │ ├── validate_division_good.stan │ ├── validate_elt_division_good.stan │ ├── validate_elt_multiplication_good.stan │ ├── validate_exponentiation_good.stan │ ├── validate_exponentiation_precedence.stan │ ├── validate_functions.stan │ ├── validate_int_divide_good.stan │ ├── validate_int_expr2_good.stan │ ├── validate_jacobian_warning_good.stan │ ├── validate_left_division_good.stan │ ├── validate_logical_negate_expr_good.stan │ ├── validate_modulus_good.stan │ ├── validate_multiplication.stan │ ├── validate_negate_expr_good.stan │ ├── validate_set_double_offset_multiplier_good.stan │ ├── validate_set_double_range_lower_good.stan │ ├── validate_set_double_range_upper_good.stan │ ├── validate_set_fun_type_named_good.stan │ ├── validate_set_int_range_lower_good.stan │ ├── validate_set_int_range_upper_good.stan │ ├── validate_validate_int_expr_good.stan │ ├── var-decl-after-statement.stan │ ├── var-decls-in-functions.stan │ ├── var-ending-lpdf.stan │ ├── variational │ │ ├── dune │ │ ├── eta_should_be_big.stan │ │ ├── eta_should_be_small.stan │ │ ├── eta_should_fail.stan │ │ ├── gradient_warn.stan │ │ ├── hier_logistic.stan │ │ ├── hier_logistic_cp.stan │ │ ├── multivariate_no_constraint.stan │ │ ├── multivariate_with_constraint.stan │ │ ├── pretty.expected │ │ ├── univariate_no_constraint.stan │ │ └── univariate_with_constraint.stan │ ├── vars-with-type-prefixes.stan │ ├── vec-expr │ │ ├── dune │ │ ├── index_expr.stan │ │ ├── matrix_expr_terms.stan │ │ ├── pretty.expected │ │ ├── row_vector_expr_terms.stan │ │ └── vec_expr_big.stan │ ├── vector-size-stmts.stan │ ├── vector-zero.stan │ ├── vector_size_lt_zero.stan │ └── warning │ │ ├── data_jacobian.stan │ │ ├── deprecated_syntax.stan │ │ ├── dune │ │ ├── empty.stan │ │ ├── fun_log_forward_decl.stan │ │ ├── functions-fwd-ref.stan │ │ ├── int_div_user.stan │ │ ├── integrate_1d_good.stan │ │ ├── integrate_ode_adams.stan │ │ ├── integrate_ode_bdf.stan │ │ ├── integrate_ode_deprecation.stan │ │ ├── integrate_ode_rk45.stan │ │ ├── lkj_cov_deprecation1.stan │ │ ├── lkj_cov_deprecation2.stan │ │ ├── matrix_pow_warning.stan │ │ ├── overloaded_forward_decl.stan │ │ ├── pretty.expected │ │ ├── self-assign.stan │ │ ├── unreachable_statement.stan │ │ └── validate_division_int_warning.stan ├── included │ ├── badrecurse1.stan │ ├── badrecurse2.stan │ ├── badrecurse3.stan │ ├── dune │ ├── error_spread_over_files.stan │ ├── incl-err.stan │ ├── incl_stanc_helper.stan │ ├── incl_stanc_helper2.stan │ ├── incl_stanc_helper_error_spread_over_files.stan │ ├── incl_stanc_helper_include_error.stan │ ├── incl_stanc_helper_lex_error.stan │ ├── incl_stanc_helper_parse_error.stan │ ├── incl_stanc_helper_semantic_error.stan │ ├── included-brackets.stan │ ├── included-quote.stan │ ├── lex-err.stan │ ├── parse-err.stan │ ├── sem-err.stan │ ├── stanc.expected │ ├── stanc_helper_with_bad_include_error_spread_over_files.stan │ ├── stanc_helper_with_bad_include_include_error.stan │ ├── stanc_helper_with_bad_include_lex_error.stan │ ├── stanc_helper_with_bad_include_parse_error.stan │ ├── stanc_helper_with_bad_include_semantic_error.stan │ ├── stanc_helper_with_good_include.stan │ └── stanc_helper_with_good_include_err_after_incl.stan ├── run_bin_on_args.ml └── signatures │ ├── stan_math_distributions.t │ └── stan_math_signatures.t ├── stancjs ├── allow-undefined.js ├── auto-format.js ├── bad_inputs.js ├── basic.js ├── canonical.js ├── data-generation.js ├── debug.js ├── dune ├── filename.js ├── functions-only.js ├── good_after_bad.js ├── includes.js ├── info.js ├── math_sigs.js ├── model_name.js ├── optimization.js ├── pedantic.js ├── removed.js ├── run_js_on_args.ml ├── stancjs.expected ├── standalone-functions.js ├── utils │ └── utils.js ├── version.js └── warnings.js └── unit ├── Ast_to_Mir_tests.ml ├── Dataflow_utils.ml ├── Debug_data_generation_tests.ml ├── Dependence_analysis.ml ├── Desugar_test.ml ├── Error_tests.ml ├── Factor_graph.ml ├── In_memory_include_tests.ml ├── Optimize.ml ├── Parse_tests.ml ├── Semantic_check_tests.ml ├── Stan_math_code_gen_tests.ml ├── Test_utils.ml └── dune /.git-blame-ignore-revs: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/.git-blame-ignore-revs -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/.gitattributes -------------------------------------------------------------------------------- /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | github: stan-dev 2 | custom: https://mc-stan.org/support/ 3 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/bug-report.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/.github/ISSUE_TEMPLATE/bug-report.md -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/config.yml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/.github/ISSUE_TEMPLATE/config.yml -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/feature-request.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/.github/ISSUE_TEMPLATE/feature-request.md -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/todo.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/.github/ISSUE_TEMPLATE/todo.md -------------------------------------------------------------------------------- /.github/codecov.yml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/.github/codecov.yml -------------------------------------------------------------------------------- /.github/pull_request_template.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/.github/pull_request_template.md -------------------------------------------------------------------------------- /.github/workflows/binaries.yml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/.github/workflows/binaries.yml -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/.gitignore -------------------------------------------------------------------------------- /.ocamlformat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/.ocamlformat -------------------------------------------------------------------------------- /Jenkinsfile: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/Jenkinsfile -------------------------------------------------------------------------------- /Jenkinsfile-test-binaries: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/Jenkinsfile-test-binaries -------------------------------------------------------------------------------- /LICENSE.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/LICENSE.txt -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/Makefile -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/README.md -------------------------------------------------------------------------------- /RELEASE-NOTES.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/RELEASE-NOTES.txt -------------------------------------------------------------------------------- /docs/core_ideas.mld: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/docs/core_ideas.mld -------------------------------------------------------------------------------- /docs/cpp_ir.mld: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/docs/cpp_ir.mld -------------------------------------------------------------------------------- /docs/dependencies.mld: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/docs/dependencies.mld -------------------------------------------------------------------------------- /docs/dune: -------------------------------------------------------------------------------- 1 | (documentation) 2 | -------------------------------------------------------------------------------- /docs/exposing_new_functions.mld: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/docs/exposing_new_functions.mld -------------------------------------------------------------------------------- /docs/getting_started.mld: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/docs/getting_started.mld -------------------------------------------------------------------------------- /docs/img/architecture.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/docs/img/architecture.png -------------------------------------------------------------------------------- /docs/img/information-flow.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/docs/img/information-flow.png -------------------------------------------------------------------------------- /docs/index.mld: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/docs/index.mld -------------------------------------------------------------------------------- /docs/notes/cpp-expression-generation.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/docs/notes/cpp-expression-generation.txt -------------------------------------------------------------------------------- /docs/notes/cpp-statement-generation.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/docs/notes/cpp-statement-generation.txt -------------------------------------------------------------------------------- /docs/notes/stancon_models.tests: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/docs/notes/stancon_models.tests -------------------------------------------------------------------------------- /docs/notes/tested-optimizations.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/docs/notes/tested-optimizations.txt -------------------------------------------------------------------------------- /docs/parser_messages.mld: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/docs/parser_messages.mld -------------------------------------------------------------------------------- /dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/dune -------------------------------------------------------------------------------- /dune-project: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/dune-project -------------------------------------------------------------------------------- /scripts/docker/ci/Dockerfile: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/scripts/docker/ci/Dockerfile -------------------------------------------------------------------------------- /scripts/docker/static-builder/Dockerfile: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/scripts/docker/static-builder/Dockerfile -------------------------------------------------------------------------------- /scripts/hooks/install_hooks.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/scripts/hooks/install_hooks.sh -------------------------------------------------------------------------------- /scripts/hooks/pre-commit: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/scripts/hooks/pre-commit -------------------------------------------------------------------------------- /scripts/install_build_deps.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/scripts/install_build_deps.sh -------------------------------------------------------------------------------- /scripts/install_build_deps_windows.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/scripts/install_build_deps_windows.sh -------------------------------------------------------------------------------- /scripts/install_dev_deps.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/scripts/install_dev_deps.sh -------------------------------------------------------------------------------- /scripts/install_js_deps.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/scripts/install_js_deps.sh -------------------------------------------------------------------------------- /scripts/install_ocaml.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/scripts/install_ocaml.sh -------------------------------------------------------------------------------- /scripts/install_opam.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/scripts/install_opam.sh -------------------------------------------------------------------------------- /scripts/nix_old/README.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/scripts/nix_old/README.md -------------------------------------------------------------------------------- /scripts/nix_old/default.nix: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/scripts/nix_old/default.nix -------------------------------------------------------------------------------- /scripts/nix_old/shell.nix: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/scripts/nix_old/shell.nix -------------------------------------------------------------------------------- /scripts/setup_dev_env.sh: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/scripts/setup_dev_env.sh -------------------------------------------------------------------------------- /src/analysis_and_optimization/Optimize.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/analysis_and_optimization/Optimize.ml -------------------------------------------------------------------------------- /src/analysis_and_optimization/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/analysis_and_optimization/dune -------------------------------------------------------------------------------- /src/common/Gensym.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/common/Gensym.ml -------------------------------------------------------------------------------- /src/common/Gensym.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/common/Gensym.mli -------------------------------------------------------------------------------- /src/common/ICE.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/common/ICE.ml -------------------------------------------------------------------------------- /src/common/Let_syntax.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/common/Let_syntax.ml -------------------------------------------------------------------------------- /src/common/Nonempty_list.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/common/Nonempty_list.ml -------------------------------------------------------------------------------- /src/common/Nonempty_list.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/common/Nonempty_list.mli -------------------------------------------------------------------------------- /src/common/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/common/dune -------------------------------------------------------------------------------- /src/driver/Entry.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/driver/Entry.ml -------------------------------------------------------------------------------- /src/driver/Entry.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/driver/Entry.mli -------------------------------------------------------------------------------- /src/driver/Flags.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/driver/Flags.ml -------------------------------------------------------------------------------- /src/driver/Flags.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/driver/Flags.mli -------------------------------------------------------------------------------- /src/driver/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/driver/dune -------------------------------------------------------------------------------- /src/frontend/Ast.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Ast.ml -------------------------------------------------------------------------------- /src/frontend/Ast_to_Mir.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Ast_to_Mir.ml -------------------------------------------------------------------------------- /src/frontend/Ast_to_Mir.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Ast_to_Mir.mli -------------------------------------------------------------------------------- /src/frontend/Canonicalize.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Canonicalize.ml -------------------------------------------------------------------------------- /src/frontend/Canonicalize.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Canonicalize.mli -------------------------------------------------------------------------------- /src/frontend/Debugging.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Debugging.ml -------------------------------------------------------------------------------- /src/frontend/Deprecation_analysis.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Deprecation_analysis.ml -------------------------------------------------------------------------------- /src/frontend/Deprecation_analysis.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Deprecation_analysis.mli -------------------------------------------------------------------------------- /src/frontend/Environment.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Environment.ml -------------------------------------------------------------------------------- /src/frontend/Environment.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Environment.mli -------------------------------------------------------------------------------- /src/frontend/Errors.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Errors.ml -------------------------------------------------------------------------------- /src/frontend/Errors.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Errors.mli -------------------------------------------------------------------------------- /src/frontend/Include_files.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Include_files.ml -------------------------------------------------------------------------------- /src/frontend/Info.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Info.ml -------------------------------------------------------------------------------- /src/frontend/Info.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Info.mli -------------------------------------------------------------------------------- /src/frontend/Input_warnings.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Input_warnings.ml -------------------------------------------------------------------------------- /src/frontend/Input_warnings.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Input_warnings.mli -------------------------------------------------------------------------------- /src/frontend/Parse.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Parse.ml -------------------------------------------------------------------------------- /src/frontend/Parse.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Parse.mli -------------------------------------------------------------------------------- /src/frontend/Preprocessor.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Preprocessor.ml -------------------------------------------------------------------------------- /src/frontend/Preprocessor.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Preprocessor.mli -------------------------------------------------------------------------------- /src/frontend/Pretty_print_prog.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Pretty_print_prog.ml -------------------------------------------------------------------------------- /src/frontend/Pretty_print_prog.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Pretty_print_prog.mli -------------------------------------------------------------------------------- /src/frontend/Pretty_printing.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Pretty_printing.ml -------------------------------------------------------------------------------- /src/frontend/Promotion.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Promotion.ml -------------------------------------------------------------------------------- /src/frontend/Semantic_error.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Semantic_error.ml -------------------------------------------------------------------------------- /src/frontend/Semantic_error.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Semantic_error.mli -------------------------------------------------------------------------------- /src/frontend/SignatureMismatch.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/SignatureMismatch.ml -------------------------------------------------------------------------------- /src/frontend/SignatureMismatch.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/SignatureMismatch.mli -------------------------------------------------------------------------------- /src/frontend/Syntax_error.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Syntax_error.ml -------------------------------------------------------------------------------- /src/frontend/Syntax_error.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Syntax_error.mli -------------------------------------------------------------------------------- /src/frontend/Typechecker.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Typechecker.ml -------------------------------------------------------------------------------- /src/frontend/Typechecker.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Typechecker.mli -------------------------------------------------------------------------------- /src/frontend/Warnings.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Warnings.ml -------------------------------------------------------------------------------- /src/frontend/Warnings.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/Warnings.mli -------------------------------------------------------------------------------- /src/frontend/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/dune -------------------------------------------------------------------------------- /src/frontend/lexer.mll: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/lexer.mll -------------------------------------------------------------------------------- /src/frontend/parser.messages: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/parser.messages -------------------------------------------------------------------------------- /src/frontend/parser.mly: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/parser.mly -------------------------------------------------------------------------------- /src/frontend/parser_messages_add_type.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/frontend/parser_messages_add_type.ml -------------------------------------------------------------------------------- /src/middle/Expr.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Expr.ml -------------------------------------------------------------------------------- /src/middle/Expr.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Expr.mli -------------------------------------------------------------------------------- /src/middle/Flag_vars.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Flag_vars.ml -------------------------------------------------------------------------------- /src/middle/Fun_kind.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Fun_kind.ml -------------------------------------------------------------------------------- /src/middle/Index.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Index.ml -------------------------------------------------------------------------------- /src/middle/Internal_fun.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Internal_fun.ml -------------------------------------------------------------------------------- /src/middle/Location.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Location.ml -------------------------------------------------------------------------------- /src/middle/Location.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Location.mli -------------------------------------------------------------------------------- /src/middle/Location_span.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Location_span.ml -------------------------------------------------------------------------------- /src/middle/Location_span.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Location_span.mli -------------------------------------------------------------------------------- /src/middle/Mem_pattern.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Mem_pattern.ml -------------------------------------------------------------------------------- /src/middle/Operator.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Operator.ml -------------------------------------------------------------------------------- /src/middle/Program.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Program.ml -------------------------------------------------------------------------------- /src/middle/SizedType.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/SizedType.ml -------------------------------------------------------------------------------- /src/middle/Stmt.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Stmt.ml -------------------------------------------------------------------------------- /src/middle/Stmt.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Stmt.mli -------------------------------------------------------------------------------- /src/middle/Transformation.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Transformation.ml -------------------------------------------------------------------------------- /src/middle/Type.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Type.ml -------------------------------------------------------------------------------- /src/middle/UnsizedType.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/UnsizedType.ml -------------------------------------------------------------------------------- /src/middle/Utils.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/Utils.ml -------------------------------------------------------------------------------- /src/middle/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/middle/dune -------------------------------------------------------------------------------- /src/stan_math_backend/Cpp.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Cpp.ml -------------------------------------------------------------------------------- /src/stan_math_backend/Cpp_Json.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Cpp_Json.ml -------------------------------------------------------------------------------- /src/stan_math_backend/Cpp_Json.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Cpp_Json.mli -------------------------------------------------------------------------------- /src/stan_math_backend/Cpp_str.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Cpp_str.ml -------------------------------------------------------------------------------- /src/stan_math_backend/Cpp_str.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Cpp_str.mli -------------------------------------------------------------------------------- /src/stan_math_backend/Lower_expr.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Lower_expr.ml -------------------------------------------------------------------------------- /src/stan_math_backend/Lower_functions.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Lower_functions.ml -------------------------------------------------------------------------------- /src/stan_math_backend/Lower_functions.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Lower_functions.mli -------------------------------------------------------------------------------- /src/stan_math_backend/Lower_program.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Lower_program.ml -------------------------------------------------------------------------------- /src/stan_math_backend/Lower_program.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Lower_program.mli -------------------------------------------------------------------------------- /src/stan_math_backend/Lower_stmt.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Lower_stmt.ml -------------------------------------------------------------------------------- /src/stan_math_backend/Mangle.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Mangle.ml -------------------------------------------------------------------------------- /src/stan_math_backend/Mangle.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Mangle.mli -------------------------------------------------------------------------------- /src/stan_math_backend/Numbering.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Numbering.ml -------------------------------------------------------------------------------- /src/stan_math_backend/Numbering.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Numbering.mli -------------------------------------------------------------------------------- /src/stan_math_backend/Transform_Mir.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Transform_Mir.ml -------------------------------------------------------------------------------- /src/stan_math_backend/Transform_Mir.mli: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/Transform_Mir.mli -------------------------------------------------------------------------------- /src/stan_math_backend/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_backend/dune -------------------------------------------------------------------------------- /src/stan_math_signatures/Generate.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_signatures/Generate.ml -------------------------------------------------------------------------------- /src/stan_math_signatures/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stan_math_signatures/dune -------------------------------------------------------------------------------- /src/stanc/CLI.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stanc/CLI.ml -------------------------------------------------------------------------------- /src/stanc/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stanc/dune -------------------------------------------------------------------------------- /src/stanc/stanc.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stanc/stanc.ml -------------------------------------------------------------------------------- /src/stancjs/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stancjs/dune -------------------------------------------------------------------------------- /src/stancjs/stancjs.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/src/stancjs/stancjs.ml -------------------------------------------------------------------------------- /stanc.opam: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/stanc.opam -------------------------------------------------------------------------------- /test/integration/bad/algebra_solver/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/array-expr-decl-bad1.stan: -------------------------------------------------------------------------------- 1 | data { 2 | array[1:2,2,:] real x; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/array-expr-decl-bad3.stan: -------------------------------------------------------------------------------- 1 | data { 2 | asdf real x; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/array-read-write-assign.stan: -------------------------------------------------------------------------------- 1 | generated quantities { 2 | array[2] int x = {1,2}; 3 | x[x[1]] = 2; 4 | } 5 | -------------------------------------------------------------------------------- /test/integration/bad/array_expr_bad1.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | array[3,2] real td_arr32 = { 1, 3 }; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/array_expr_bad2.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/array_expr_bad2.stan -------------------------------------------------------------------------------- /test/integration/bad/assign_invalid_lhs1.stan: -------------------------------------------------------------------------------- 1 | model { 2 | foo() = 1; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/assign_invalid_lhs2.stan: -------------------------------------------------------------------------------- 1 | generated quantities { 2 | [x,y,z] = [1,2,3]; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/bad_to_int1.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/bad_to_int1.stan -------------------------------------------------------------------------------- /test/integration/bad/bad_to_int2.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/bad_to_int2.stan -------------------------------------------------------------------------------- /test/integration/bad/bad_while.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/bad_while.stan -------------------------------------------------------------------------------- /test/integration/bad/break1.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/break1.stan -------------------------------------------------------------------------------- /test/integration/bad/break2.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/break2.stan -------------------------------------------------------------------------------- /test/integration/bad/break3.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/break3.stan -------------------------------------------------------------------------------- /test/integration/bad/break4.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/break4.stan -------------------------------------------------------------------------------- /test/integration/bad/break5.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/break5.stan -------------------------------------------------------------------------------- /test/integration/bad/break6.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/break6.stan -------------------------------------------------------------------------------- /test/integration/bad/break7.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/break7.stan -------------------------------------------------------------------------------- /test/integration/bad/break8.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/break8.stan -------------------------------------------------------------------------------- /test/integration/bad/ccdf-sample.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/ccdf-sample.stan -------------------------------------------------------------------------------- /test/integration/bad/cdf-sample.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/cdf-sample.stan -------------------------------------------------------------------------------- /test/integration/bad/complex-numbers/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/complex_mat_bad.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/complex_mat_bad.stan -------------------------------------------------------------------------------- /test/integration/bad/compound-assign/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/continue1.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/continue1.stan -------------------------------------------------------------------------------- /test/integration/bad/continue2.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/continue2.stan -------------------------------------------------------------------------------- /test/integration/bad/continue3.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/continue3.stan -------------------------------------------------------------------------------- /test/integration/bad/continue4.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/continue4.stan -------------------------------------------------------------------------------- /test/integration/bad/continue5.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/continue5.stan -------------------------------------------------------------------------------- /test/integration/bad/data_index/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/decl-mutual-inits.stan: -------------------------------------------------------------------------------- 1 | transformed parameters { 2 | real x = y, y = x; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/decl-reuse-name.stan: -------------------------------------------------------------------------------- 1 | parameters { 2 | real x, y, x; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/dune -------------------------------------------------------------------------------- /test/integration/bad/embedded_laplace/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/embedded_laplace/missing_args1.stan: -------------------------------------------------------------------------------- 1 | model { 2 | target += laplace_marginal(); 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/embedded_laplace/missing_args2.stan: -------------------------------------------------------------------------------- 1 | model { 2 | target += laplace_marginal_tol(); 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/err-close-block.stan: -------------------------------------------------------------------------------- 1 | functions { 2 | 3 | model { 4 | } 5 | -------------------------------------------------------------------------------- /test/integration/bad/err-decl-double.stan: -------------------------------------------------------------------------------- 1 | data { 2 | double y; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/err-decl-matrix-2.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real y; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/err-decl-matrix.stan: -------------------------------------------------------------------------------- 1 | data { 2 | matrix[3] y; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/err-decl-no-expression.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real y; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/err-decl-vector-2.stan: -------------------------------------------------------------------------------- 1 | data { 2 | vector[3,4] y; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/err-decl-vector.stan: -------------------------------------------------------------------------------- 1 | data { 2 | vector a[3]; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/err-double-dims.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | array[2.3] real y; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/err-expected-bracket.stan: -------------------------------------------------------------------------------- 1 | model { 2 | } 3 | generated quantities 4 | -------------------------------------------------------------------------------- /test/integration/bad/err-expected-end-of-model.stan: -------------------------------------------------------------------------------- 1 | model { 2 | } 3 | foo 4 | -------------------------------------------------------------------------------- /test/integration/bad/err-if-else.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/err-if-else.stan -------------------------------------------------------------------------------- /test/integration/bad/err-minus-types.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/err-minus-types.stan -------------------------------------------------------------------------------- /test/integration/bad/err-nested-parens-close.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | real x; 3 | x = (2 + 3; 4 | } 5 | -------------------------------------------------------------------------------- /test/integration/bad/err-nested-parens.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | real x; 3 | x = 2 + (()); 4 | } 5 | -------------------------------------------------------------------------------- /test/integration/bad/err-no-cond.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/err-no-cond.stan -------------------------------------------------------------------------------- /test/integration/bad/err-open-block.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/err-open-block.stan -------------------------------------------------------------------------------- /test/integration/bad/experiment.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/experiment.stan -------------------------------------------------------------------------------- /test/integration/bad/for_loops/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/fun-return-typ3.stan: -------------------------------------------------------------------------------- 1 | functions { 2 | real foo() reject(""); 3 | } -------------------------------------------------------------------------------- /test/integration/bad/function-signatures/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/function-signatures/overloading/dune: -------------------------------------------------------------------------------- 1 | (include ../../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/functions-bad0.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad0.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad1.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad1.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad11.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad11.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad12.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad12.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad13.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad13.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad14.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad14.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad15.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad15.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad16.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad16.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad17.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad17.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad18.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad18.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad19.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad19.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad2.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad2.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad20.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad20.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad21.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad21.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad23.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad23.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad24.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad24.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad25.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad25.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad26.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad26.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad27.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad27.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad28.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad28.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad29.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad29.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad3.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad3.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad30.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad30.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad31.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad31.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad32.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad32.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad4.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad4.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad5.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad5.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad6.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad6.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad7.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad7.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad8.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad8.stan -------------------------------------------------------------------------------- /test/integration/bad/functions-bad9.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/functions-bad9.stan -------------------------------------------------------------------------------- /test/integration/bad/hmm_hidden_state_prob/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/jacobian_pe_bad.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/jacobian_pe_bad.stan -------------------------------------------------------------------------------- /test/integration/bad/lang/bad1.stan: -------------------------------------------------------------------------------- 1 | model { -------------------------------------------------------------------------------- /test/integration/bad/lang/bad1.stanfunctions: -------------------------------------------------------------------------------- 1 | int x; 2 | -------------------------------------------------------------------------------- /test/integration/bad/lang/bad10.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real y__; 3 | } 4 | model { 5 | } -------------------------------------------------------------------------------- /test/integration/bad/lang/bad11.stan: -------------------------------------------------------------------------------- 1 | parameters { 2 | int theta; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/lang/bad12.stan: -------------------------------------------------------------------------------- 1 | generated quantities { 2 | beta = 1; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/lang/bad2.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lang/bad2.stan -------------------------------------------------------------------------------- /test/integration/bad/lang/bad3.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lang/bad3.stan -------------------------------------------------------------------------------- /test/integration/bad/lang/bad3.stanfunctions: -------------------------------------------------------------------------------- 1 | while; 2 | -------------------------------------------------------------------------------- /test/integration/bad/lang/bad4.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lang/bad4.stan -------------------------------------------------------------------------------- /test/integration/bad/lang/bad5.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lang/bad5.stan -------------------------------------------------------------------------------- /test/integration/bad/lang/bad6.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lang/bad6.stan -------------------------------------------------------------------------------- /test/integration/bad/lang/bad7.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lang/bad7.stan -------------------------------------------------------------------------------- /test/integration/bad/lang/bad8.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lang/bad8.stan -------------------------------------------------------------------------------- /test/integration/bad/lang/bad9.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lang/bad9.stan -------------------------------------------------------------------------------- /test/integration/bad/lang/bad_bar.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lang/bad_bar.stan -------------------------------------------------------------------------------- /test/integration/bad/lang/bad_decl1.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real x, int y; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/lang/bad_decl2.stan: -------------------------------------------------------------------------------- 1 | data { 2 | array[3,3] x; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/lang/bad_decl3.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lang/bad_decl3.stan -------------------------------------------------------------------------------- /test/integration/bad/lang/bad_decl4.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real x, reject; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/lang/bad_lmpf.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lang/bad_lmpf.stan -------------------------------------------------------------------------------- /test/integration/bad/lang/bad_lpdf.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lang/bad_lpdf.stan -------------------------------------------------------------------------------- /test/integration/bad/lang/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/lang/good_all.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lang/good_all.stan -------------------------------------------------------------------------------- /test/integration/bad/lang/incomplete.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | real x = 2.0 .^ ; 3 | } -------------------------------------------------------------------------------- /test/integration/bad/lang/incomplete2.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | 1.0 .^ foo[] while 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/lang/incomplete3.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | 2.0 %/% while (1) { print("hi"); } 3 | } -------------------------------------------------------------------------------- /test/integration/bad/lang/incomplete4.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | 2.0 %/% 1.0; while (1) { print("hi"); } 3 | } -------------------------------------------------------------------------------- /test/integration/bad/lang/incomplete5.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | if (2.0) ; 3 | -------------------------------------------------------------------------------- /test/integration/bad/lang/incomplete6.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | print(foo[2.0]); 3 | real x = sars[while (0)]; 4 | } 5 | -------------------------------------------------------------------------------- /test/integration/bad/lang/stanc.expected: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lang/stanc.expected -------------------------------------------------------------------------------- /test/integration/bad/lang/tparam_array_int.stan: -------------------------------------------------------------------------------- 1 | transformed parameters { 2 | array[1,2,3] int x; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/lang/tparam_tuple_int.stan: -------------------------------------------------------------------------------- 1 | transformed parameters { 2 | tuple(real, int) x; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/lang/unterminated_comment.stan: -------------------------------------------------------------------------------- 1 | /* this comment 2 | never 3 | ends 4 | -------------------------------------------------------------------------------- /test/integration/bad/log_suffix_bad1.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/log_suffix_bad1.stan -------------------------------------------------------------------------------- /test/integration/bad/log_suffix_bad2.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/log_suffix_bad2.stan -------------------------------------------------------------------------------- /test/integration/bad/lp-error.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lp-error.stan -------------------------------------------------------------------------------- /test/integration/bad/lvalue_indexes1.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lvalue_indexes1.stan -------------------------------------------------------------------------------- /test/integration/bad/lvalue_indexes2.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/lvalue_indexes2.stan -------------------------------------------------------------------------------- /test/integration/bad/map_rect/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/missing-pmf.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/missing-pmf.stan -------------------------------------------------------------------------------- /test/integration/bad/missing_dist_suffix/completely_undefined1.stan: -------------------------------------------------------------------------------- 1 | model { 2 | target += foo_lpdf(1); 3 | } -------------------------------------------------------------------------------- /test/integration/bad/missing_dist_suffix/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/multiply_sample.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/multiply_sample.stan -------------------------------------------------------------------------------- /test/integration/bad/new/arg-decl-bad1.stan: -------------------------------------------------------------------------------- 1 | functions { 2 | void foo(int x, while); 3 | } -------------------------------------------------------------------------------- /test/integration/bad/new/blocks-bad1.stan: -------------------------------------------------------------------------------- 1 | data while -------------------------------------------------------------------------------- /test/integration/bad/new/blocks-bad10.stan: -------------------------------------------------------------------------------- 1 | transformed data while -------------------------------------------------------------------------------- /test/integration/bad/new/blocks-bad11.stan: -------------------------------------------------------------------------------- 1 | transformed parameters { void -------------------------------------------------------------------------------- /test/integration/bad/new/blocks-bad12.stan: -------------------------------------------------------------------------------- 1 | transformed parameters while -------------------------------------------------------------------------------- /test/integration/bad/new/blocks-bad2.stan: -------------------------------------------------------------------------------- 1 | functions {} cov_matrix -------------------------------------------------------------------------------- /test/integration/bad/new/blocks-bad3.stan: -------------------------------------------------------------------------------- 1 | model while -------------------------------------------------------------------------------- /test/integration/bad/new/blocks-bad4.stan: -------------------------------------------------------------------------------- 1 | parameters { while } -------------------------------------------------------------------------------- /test/integration/bad/new/blocks-bad5.stan: -------------------------------------------------------------------------------- 1 | parameters while -------------------------------------------------------------------------------- /test/integration/bad/new/blocks-bad6.stan: -------------------------------------------------------------------------------- 1 | transformed data { ! 1.0 while } -------------------------------------------------------------------------------- /test/integration/bad/new/blocks-bad7.stan: -------------------------------------------------------------------------------- 1 | transformed data { } .*= -------------------------------------------------------------------------------- /test/integration/bad/new/blocks-bad8.stan: -------------------------------------------------------------------------------- 1 | transformed data { T } -------------------------------------------------------------------------------- /test/integration/bad/new/blocks-bad9.stan: -------------------------------------------------------------------------------- 1 | transformed data { void -------------------------------------------------------------------------------- /test/integration/bad/new/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/new/fatal_error-bad1.stan: -------------------------------------------------------------------------------- 1 | transformed data { fatal_error ( "hello world" while 2 | -------------------------------------------------------------------------------- /test/integration/bad/new/fun-app-bad1.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ( 1.0 | T] -------------------------------------------------------------------------------- /test/integration/bad/new/fun-app-bad2.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ( 1.0 | while -------------------------------------------------------------------------------- /test/integration/bad/new/fun-app-bad3.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ( 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/fun-app-bad4.stan: -------------------------------------------------------------------------------- 1 | transformed data { T () while -------------------------------------------------------------------------------- /test/integration/bad/new/fun-app-bad5.stan: -------------------------------------------------------------------------------- 1 | transformed data { T (T| T] -------------------------------------------------------------------------------- /test/integration/bad/new/fun-app-bad6.stan: -------------------------------------------------------------------------------- 1 | transformed data { T (T| while -------------------------------------------------------------------------------- /test/integration/bad/new/fun-app-bad7.stan: -------------------------------------------------------------------------------- 1 | transformed data { T (T, id] -------------------------------------------------------------------------------- /test/integration/bad/new/fun-app-bad8.stan: -------------------------------------------------------------------------------- 1 | transformed data { T (T~ -------------------------------------------------------------------------------- /test/integration/bad/new/fun-app-bad9.stan: -------------------------------------------------------------------------------- 1 | transformed data { T (while -------------------------------------------------------------------------------- /test/integration/bad/new/fundef-bad2.stan: -------------------------------------------------------------------------------- 1 | functions { vector foo } 2 | -------------------------------------------------------------------------------- /test/integration/bad/new/fundef-bad3.stan: -------------------------------------------------------------------------------- 1 | functions { void id(); while } -------------------------------------------------------------------------------- /test/integration/bad/new/fundef-bad4.stan: -------------------------------------------------------------------------------- 1 | functions { void T(data while); } -------------------------------------------------------------------------------- /test/integration/bad/new/fundef-bad5.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/fundef-bad5.stan -------------------------------------------------------------------------------- /test/integration/bad/new/fundef-bad6.stan: -------------------------------------------------------------------------------- 1 | functions { void T ( array [] vector while);} 2 | -------------------------------------------------------------------------------- /test/integration/bad/new/fundef-bad7.stan: -------------------------------------------------------------------------------- 1 | functions { void T ( while x);} -------------------------------------------------------------------------------- /test/integration/bad/new/fundef-bad8.stan: -------------------------------------------------------------------------------- 1 | functions { void while();} -------------------------------------------------------------------------------- /test/integration/bad/new/fundef-bad9.stan: -------------------------------------------------------------------------------- 1 | generated quantities { void foo(); } -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression1.stan: -------------------------------------------------------------------------------- 1 | transformed data { real x = T/0.0 while;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression10.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression11.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression12.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression13.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression14.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression15.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression16.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression17.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression18.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression19.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression2.stan: -------------------------------------------------------------------------------- 1 | model { 2 | normal(0, 1.0 while); 3 | } -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression20.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression21.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression22.stan: -------------------------------------------------------------------------------- 1 | model { 2 | if (2) then {print (0);} 3 | } -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression23.stan: -------------------------------------------------------------------------------- 1 | model { real T = 0.0 while;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression24.stan: -------------------------------------------------------------------------------- 1 | model { real T = T ~ normal(0,1);} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression25.stan: -------------------------------------------------------------------------------- 1 | model { real T = while ;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression28.stan: -------------------------------------------------------------------------------- 1 | transformed data { ! while} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression29.stan: -------------------------------------------------------------------------------- 1 | transformed data { {1.0, while}} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression3.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression30.stan: -------------------------------------------------------------------------------- 1 | transformed data { {1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression31.stan: -------------------------------------------------------------------------------- 1 | transformed data { {void -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression32.stan: -------------------------------------------------------------------------------- 1 | transformed data { {T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression33.stan: -------------------------------------------------------------------------------- 1 | transformed data { [ 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression34.stan: -------------------------------------------------------------------------------- 1 | transformed data { [ T, while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression35.stan: -------------------------------------------------------------------------------- 1 | transformed data { [ T) -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression36.stan: -------------------------------------------------------------------------------- 1 | transformed data { -T [ ] while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression37.stan: -------------------------------------------------------------------------------- 1 | transformed data { + 0.1 while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression38.stan: -------------------------------------------------------------------------------- 1 | transformed data { - while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression39.stan: -------------------------------------------------------------------------------- 1 | transformed data { + T [] while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression4.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression40.stan: -------------------------------------------------------------------------------- 1 | transformed data { + while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression41.stan: -------------------------------------------------------------------------------- 1 | transformed data { x= 1 && while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression42.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 / while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression43.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 ./ while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression44.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 .* while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression45.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 == while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression46.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 >= while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression47.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 ^ while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression48.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 < while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression49.stan: -------------------------------------------------------------------------------- 1 | transformed data { x[ : while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression5.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression50.stan: -------------------------------------------------------------------------------- 1 | transformed data { x[32:while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression51.stan: -------------------------------------------------------------------------------- 1 | transformed data { x[T :while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression52.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 \ while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression53.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 <= while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression54.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 - while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression55.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 % while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression56.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 != while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression57.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 || while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression58.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 + while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression6.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression61.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 ? T : while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression62.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 ? while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression63.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 > while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression64.stan: -------------------------------------------------------------------------------- 1 | model { 1.0 * while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression65.stan: -------------------------------------------------------------------------------- 1 | transformed data { return T(T,x] -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression66.stan: -------------------------------------------------------------------------------- 1 | transformed data { return T(while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression67.stan: -------------------------------------------------------------------------------- 1 | transformed data { T && while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression68.stan: -------------------------------------------------------------------------------- 1 | transformed data { T = while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression69.stan: -------------------------------------------------------------------------------- 1 | transformed data { T = while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression7.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression70.stan: -------------------------------------------------------------------------------- 1 | transformed data { T / while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression71.stan: -------------------------------------------------------------------------------- 1 | transformed data { T /= while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression72.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ./ while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression73.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ./= while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression74.stan: -------------------------------------------------------------------------------- 1 | transformed data { T .* while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression75.stan: -------------------------------------------------------------------------------- 1 | transformed data { T .*= while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression76.stan: -------------------------------------------------------------------------------- 1 | transformed data { T == while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression77.stan: -------------------------------------------------------------------------------- 1 | transformed data { T <= while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression78.stan: -------------------------------------------------------------------------------- 1 | transformed data { T >= while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression79.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ^ while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression8.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression80.stan: -------------------------------------------------------------------------------- 1 | transformed data { T < while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression81.stan: -------------------------------------------------------------------------------- 1 | transformed data { T \ while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression82.stan: -------------------------------------------------------------------------------- 1 | transformed data { T - while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression83.stan: -------------------------------------------------------------------------------- 1 | transformed data { T % while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression84.stan: -------------------------------------------------------------------------------- 1 | transformed data { T != while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression85.stan: -------------------------------------------------------------------------------- 1 | transformed data { T || while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression86.stan: -------------------------------------------------------------------------------- 1 | transformed data { T + while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression87.stan: -------------------------------------------------------------------------------- 1 | transformed data { T += while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression88.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ? 1.0 : while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression89.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ? while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression9.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression90.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ? T~ -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression91.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ? while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression92.stan: -------------------------------------------------------------------------------- 1 | transformed data { T > while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression93.stan: -------------------------------------------------------------------------------- 1 | transformed data { T * while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-expression94.stan: -------------------------------------------------------------------------------- 1 | transformed data { T *= while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement1.stan: -------------------------------------------------------------------------------- 1 | transformed data { break while} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement14.stan: -------------------------------------------------------------------------------- 1 | transformed data { for ( T in T: while)} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement17.stan: -------------------------------------------------------------------------------- 1 | transformed data { for ( T in while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement18.stan: -------------------------------------------------------------------------------- 1 | transformed data { for ( T while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement19.stan: -------------------------------------------------------------------------------- 1 | transformed data { for ( while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement2.stan: -------------------------------------------------------------------------------- 1 | transformed data { continue while} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement20.stan: -------------------------------------------------------------------------------- 1 | transformed data { for while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement23.stan: -------------------------------------------------------------------------------- 1 | transformed data { if ( 1 ) ; else void} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement24.stan: -------------------------------------------------------------------------------- 1 | transformed data { if ( 1 ) ; foo} 2 | -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement25.stan: -------------------------------------------------------------------------------- 1 | transformed data { if ( T) ; else void -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement26.stan: -------------------------------------------------------------------------------- 1 | transformed data { if ( T) ; foo 2 | -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement27.stan: -------------------------------------------------------------------------------- 1 | transformed data { if ( T ) void -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement28.stan: -------------------------------------------------------------------------------- 1 | transformed data { if (T ~ normal(0,1))} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement3.stan: -------------------------------------------------------------------------------- 1 | transformed data { for ( T in 1:42) void} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement30.stan: -------------------------------------------------------------------------------- 1 | transformed data { increment_log_prob ( 1 while} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement35.stan: -------------------------------------------------------------------------------- 1 | transformed data { -1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement4.stan: -------------------------------------------------------------------------------- 1 | transformed data { for ( T in 1:24 while} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement5.stan: -------------------------------------------------------------------------------- 1 | transformed data { for ( T in 1:T)void -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement7.stan: -------------------------------------------------------------------------------- 1 | transformed data { for ( T in 1: while)} -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement8.stan: -------------------------------------------------------------------------------- 1 | transformed data { for ( T in 1) void } -------------------------------------------------------------------------------- /test/integration/bad/new/ill-formed-statement9.stan: -------------------------------------------------------------------------------- 1 | transformed data { for ( T in 1 while)} -------------------------------------------------------------------------------- /test/integration/bad/new/immediate_error.stan: -------------------------------------------------------------------------------- 1 | while -------------------------------------------------------------------------------- /test/integration/bad/new/indices-bad1.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 [ , while -------------------------------------------------------------------------------- /test/integration/bad/new/indices-bad2.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0[ while -------------------------------------------------------------------------------- /test/integration/bad/new/indices-bad3.stan: -------------------------------------------------------------------------------- 1 | transformed data { T [while -------------------------------------------------------------------------------- /test/integration/bad/new/lexing_error.stan: -------------------------------------------------------------------------------- 1 | model {½ } -------------------------------------------------------------------------------- /test/integration/bad/new/location-scale-bad1.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/location-scale-bad10.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/location-scale-bad11.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/location-scale-bad3.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/location-scale-bad4.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/location-scale-bad5.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/location-scale-bad6.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/location-scale-bad7.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/location-scale-bad8.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/location-scale-bad9.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/mystery1.stan: -------------------------------------------------------------------------------- 1 | transformed data { [ T~ -------------------------------------------------------------------------------- /test/integration/bad/new/mystery10.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 .* T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery100.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ? 1.0 : T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery101.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ? 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery102.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ? T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery103.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/mystery103.stan -------------------------------------------------------------------------------- /test/integration/bad/new/mystery104.stan: -------------------------------------------------------------------------------- 1 | transformed data { T > 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery105.stan: -------------------------------------------------------------------------------- 1 | transformed data { T > T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery106.stan: -------------------------------------------------------------------------------- 1 | transformed data { T * 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery107.stan: -------------------------------------------------------------------------------- 1 | transformed data { T * T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery108.stan: -------------------------------------------------------------------------------- 1 | transformed data { T *= T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery109.stan: -------------------------------------------------------------------------------- 1 | transformed data { T *= 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery11.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 == 1 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery12.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 == T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery13.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 >= 1 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery14.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 >= T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery15.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 ^ 1 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery16.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 ^ T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery17.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 < 1 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery18.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 < T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery19.stan: -------------------------------------------------------------------------------- 1 | transformed data { x[ : 242 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery2.stan: -------------------------------------------------------------------------------- 1 | transformed data { ( T ~ -------------------------------------------------------------------------------- /test/integration/bad/new/mystery20.stan: -------------------------------------------------------------------------------- 1 | transformed data { x[ : T ~ -------------------------------------------------------------------------------- /test/integration/bad/new/mystery21.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/mystery21.stan -------------------------------------------------------------------------------- /test/integration/bad/new/mystery22.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/mystery22.stan -------------------------------------------------------------------------------- /test/integration/bad/new/mystery23.stan: -------------------------------------------------------------------------------- 1 | transformed data { x[32 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery24.stan: -------------------------------------------------------------------------------- 1 | transformed data { x[T:1 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery25.stan: -------------------------------------------------------------------------------- 1 | transformed data { x[T :T~ -------------------------------------------------------------------------------- /test/integration/bad/new/mystery26.stan: -------------------------------------------------------------------------------- 1 | transformed data { x[T ~ -------------------------------------------------------------------------------- /test/integration/bad/new/mystery27.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/mystery27.stan -------------------------------------------------------------------------------- /test/integration/bad/new/mystery28.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 \ T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery29.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/mystery29.stan -------------------------------------------------------------------------------- /test/integration/bad/new/mystery3.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 && 1 while } -------------------------------------------------------------------------------- /test/integration/bad/new/mystery30.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 <= T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery31.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/mystery31.stan -------------------------------------------------------------------------------- /test/integration/bad/new/mystery32.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 - T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery33.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/mystery33.stan -------------------------------------------------------------------------------- /test/integration/bad/new/mystery34.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 % T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery35.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/mystery35.stan -------------------------------------------------------------------------------- /test/integration/bad/new/mystery36.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 != T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery37.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/mystery37.stan -------------------------------------------------------------------------------- /test/integration/bad/new/mystery38.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 || T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery39.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/mystery39.stan -------------------------------------------------------------------------------- /test/integration/bad/new/mystery4.stan: -------------------------------------------------------------------------------- 1 | transformed data { x= 1 && T [] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery40.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 + T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery41.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/mystery41.stan -------------------------------------------------------------------------------- /test/integration/bad/new/mystery42.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/mystery42.stan -------------------------------------------------------------------------------- /test/integration/bad/new/mystery43.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/mystery43.stan -------------------------------------------------------------------------------- /test/integration/bad/new/mystery44.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 ? T : T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery45.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 ? T ~ -------------------------------------------------------------------------------- /test/integration/bad/new/mystery46.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/mystery46.stan -------------------------------------------------------------------------------- /test/integration/bad/new/mystery47.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1.0 > T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery48.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/mystery48.stan -------------------------------------------------------------------------------- /test/integration/bad/new/mystery49.stan: -------------------------------------------------------------------------------- 1 | model { 1.0 * T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery5.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 / 1 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery50.stan: -------------------------------------------------------------------------------- 1 | model { 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery51.stan: -------------------------------------------------------------------------------- 1 | transformed data { reject( T ~ -------------------------------------------------------------------------------- /test/integration/bad/new/mystery52.stan: -------------------------------------------------------------------------------- 1 | transformed data { return { T) -------------------------------------------------------------------------------- /test/integration/bad/new/mystery53.stan: -------------------------------------------------------------------------------- 1 | transformed data { return 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery54.stan: -------------------------------------------------------------------------------- 1 | transformed data { return T ~ -------------------------------------------------------------------------------- /test/integration/bad/new/mystery55.stan: -------------------------------------------------------------------------------- 1 | transformed data { T && 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery56.stan: -------------------------------------------------------------------------------- 1 | transformed data { T && T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery57.stan: -------------------------------------------------------------------------------- 1 | transformed data { T = 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery58.stan: -------------------------------------------------------------------------------- 1 | transformed data { T = T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery59.stan: -------------------------------------------------------------------------------- 1 | transformed data { T = 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery6.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 / T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery60.stan: -------------------------------------------------------------------------------- 1 | transformed data { T = T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery61.stan: -------------------------------------------------------------------------------- 1 | transformed data { T / 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery62.stan: -------------------------------------------------------------------------------- 1 | transformed data { T / T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery63.stan: -------------------------------------------------------------------------------- 1 | transformed data { T /= 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery64.stan: -------------------------------------------------------------------------------- 1 | transformed data { T /= T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery65.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ./ 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery66.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ./ T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery67.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ./= 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery68.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ./= T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery69.stan: -------------------------------------------------------------------------------- 1 | transformed data { T .* 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery7.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 ./ 1 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery70.stan: -------------------------------------------------------------------------------- 1 | transformed data { T .* T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery71.stan: -------------------------------------------------------------------------------- 1 | transformed data { T .*= 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery72.stan: -------------------------------------------------------------------------------- 1 | transformed data { T .*= T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery73.stan: -------------------------------------------------------------------------------- 1 | transformed data { T == 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery74.stan: -------------------------------------------------------------------------------- 1 | transformed data { T == T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery75.stan: -------------------------------------------------------------------------------- 1 | transformed data { T <= 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery76.stan: -------------------------------------------------------------------------------- 1 | transformed data { T <= T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery77.stan: -------------------------------------------------------------------------------- 1 | transformed data { T >= T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery78.stan: -------------------------------------------------------------------------------- 1 | transformed data { T >= 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery79.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ^ 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery8.stan: -------------------------------------------------------------------------------- 1 | transformed data { 1 ./ T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery80.stan: -------------------------------------------------------------------------------- 1 | transformed data { T ^ T[] while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery81.stan: -------------------------------------------------------------------------------- 1 | transformed data { T < 1.0 while -------------------------------------------------------------------------------- /test/integration/bad/new/mystery82.stan: -------------------------------------------------------------------------------- 1 | transformed data { T x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/transformations-bad10.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/transformations-bad11.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/transformations-bad12.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/transformations-bad13.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/transformations-bad14.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/transformations-bad15.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/transformations-bad16.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/transformations-bad17.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/transformations-bad3.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/transformations-bad4.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/transformations-bad5.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/transformations-bad6.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/transformations-bad7.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/transformations-bad8.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/transformations-bad9.stan: -------------------------------------------------------------------------------- 1 | data { vector x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-bad1.stan: -------------------------------------------------------------------------------- 1 | data { vector[1]^} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad1.stan: -------------------------------------------------------------------------------- 1 | data { cholesky_factor_cov[0.0 while] x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad10.stan: -------------------------------------------------------------------------------- 1 | data { corr_matrix[while] x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad11.stan: -------------------------------------------------------------------------------- 1 | data { corr_matrix x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad12.stan: -------------------------------------------------------------------------------- 1 | data { cov_matrix[0.0 while] x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad13.stan: -------------------------------------------------------------------------------- 1 | data { cov_matrix[T ~ normal(0,1)] x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad14.stan: -------------------------------------------------------------------------------- 1 | data { cov_matrix[while] x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad15.stan: -------------------------------------------------------------------------------- 1 | data { cov_matrix x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad16.stan: -------------------------------------------------------------------------------- 1 | data { matrix[0.0, 0.0 while] x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad17.stan: -------------------------------------------------------------------------------- 1 | data { matrix[0.0, T~normal(0,1)] x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad18.stan: -------------------------------------------------------------------------------- 1 | data { matrix[0.0, print(0)] x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad19.stan: -------------------------------------------------------------------------------- 1 | data { matrix[T, 0.0 while] x} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad2.stan: -------------------------------------------------------------------------------- 1 | data { cholesky_factor_cov[while]x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad20.stan: -------------------------------------------------------------------------------- 1 | data { matrix[T, T~normal(0,1)] x} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad21.stan: -------------------------------------------------------------------------------- 1 | data { matrix[T, print(0)] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad22.stan: -------------------------------------------------------------------------------- 1 | data { matrix[T ~ normal(0,1), 1] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad23.stan: -------------------------------------------------------------------------------- 1 | data { matrix[print(0), 1] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad24.stan: -------------------------------------------------------------------------------- 1 | data { ordered[0.0 while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad25.stan: -------------------------------------------------------------------------------- 1 | data { ordered[T ~ normal(0,1)] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad26.stan: -------------------------------------------------------------------------------- 1 | data { ordered x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad27.stan: -------------------------------------------------------------------------------- 1 | data { positive_ordered[0.0 while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad28.stan: -------------------------------------------------------------------------------- 1 | data { positive_ordered[T~normal(0,1)] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad29.stan: -------------------------------------------------------------------------------- 1 | data { positive_ordered[while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad3.stan: -------------------------------------------------------------------------------- 1 | data { cholesky_factor_cov[T,0.0 while]x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad30.stan: -------------------------------------------------------------------------------- 1 | data { positive_ordered x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad32.stan: -------------------------------------------------------------------------------- 1 | data { array[] real T;} 2 | -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad34.stan: -------------------------------------------------------------------------------- 1 | data { row_vector[0.0 while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad35.stan: -------------------------------------------------------------------------------- 1 | data { row_vector[T~normal(0,1)] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad36.stan: -------------------------------------------------------------------------------- 1 | data { row_vector[while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad37.stan: -------------------------------------------------------------------------------- 1 | data { simplex[0.0 while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad38.stan: -------------------------------------------------------------------------------- 1 | data { simplex[T ~ normal(0,1)] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad39.stan: -------------------------------------------------------------------------------- 1 | data { simplex[while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad4.stan: -------------------------------------------------------------------------------- 1 | data { cholesky_factor_cov[T,while]x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad40.stan: -------------------------------------------------------------------------------- 1 | data { unit_vector[ 0.0 while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad41.stan: -------------------------------------------------------------------------------- 1 | data { unit_vector[ T~normal(0,1)] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad42.stan: -------------------------------------------------------------------------------- 1 | data { unit_vector[ while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad43.stan: -------------------------------------------------------------------------------- 1 | data { unit_vector while;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad44.stan: -------------------------------------------------------------------------------- 1 | data { vector while;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad45.stan: -------------------------------------------------------------------------------- 1 | data { vector[T~normal(0,1)] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad46.stan: -------------------------------------------------------------------------------- 1 | data { vector[while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad47.stan: -------------------------------------------------------------------------------- 1 | model { matrix[1, 1 while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad48.stan: -------------------------------------------------------------------------------- 1 | model { matrix[0, T~normal(0,1)] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad49.stan: -------------------------------------------------------------------------------- 1 | model { matrix[0, while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad5.stan: -------------------------------------------------------------------------------- 1 | data { cholesky_factor_cov[T,T ~]x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad50.stan: -------------------------------------------------------------------------------- 1 | model { matrix[1 while,1] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad51.stan: -------------------------------------------------------------------------------- 1 | model { matrix[T,0 while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad52.stan: -------------------------------------------------------------------------------- 1 | model { matrix[ T, T ~normal(0,1)] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad53.stan: -------------------------------------------------------------------------------- 1 | model { matrix[T, while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad54.stan: -------------------------------------------------------------------------------- 1 | model { matrix[T~normal(0,1),1] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad55.stan: -------------------------------------------------------------------------------- 1 | model { matrix [ while, 1] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad56.stan: -------------------------------------------------------------------------------- 1 | model { row_vector [ 1 while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad57.stan: -------------------------------------------------------------------------------- 1 | model { row_vector[ T~normal(0,1)] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad58.stan: -------------------------------------------------------------------------------- 1 | model { row_vector [ while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad59.stan: -------------------------------------------------------------------------------- 1 | model { vector [ 1 while ] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad6.stan: -------------------------------------------------------------------------------- 1 | data { cholesky_factor_cov[T ~]x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad60.stan: -------------------------------------------------------------------------------- 1 | model { vector [ T~normal(0,1)] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad61.stan: -------------------------------------------------------------------------------- 1 | model { vector[ while] x;} -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad62.stan: -------------------------------------------------------------------------------- 1 | data { 2 | complex_vector[foo 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad7.stan: -------------------------------------------------------------------------------- 1 | data { cholesky_factor_cov x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad8.stan: -------------------------------------------------------------------------------- 1 | data { corr_matrix[0.0 while] x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/type-size-bad9.stan: -------------------------------------------------------------------------------- 1 | data { corr_matrix[T ~ normal(0,1)] x; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/variable-decl-bad1.stan: -------------------------------------------------------------------------------- 1 | data { int; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/variable-decl-bad2.stan: -------------------------------------------------------------------------------- 1 | data { matrix; 2 | } -------------------------------------------------------------------------------- /test/integration/bad/new/variable-decl-bad4.stan: -------------------------------------------------------------------------------- 1 | data { row_vector print(0);} -------------------------------------------------------------------------------- /test/integration/bad/new/variable-decl-bad5.stan: -------------------------------------------------------------------------------- 1 | data { row_vector while;} -------------------------------------------------------------------------------- /test/integration/bad/new/variable-decl-bad6.stan: -------------------------------------------------------------------------------- 1 | data { simplex while;} -------------------------------------------------------------------------------- /test/integration/bad/new/variable-decl-bad7.stan: -------------------------------------------------------------------------------- 1 | transformed data { vector[1]^ -------------------------------------------------------------------------------- /test/integration/bad/new/while-bad1.stan: -------------------------------------------------------------------------------- 1 | transformed data { while (1.0) void -------------------------------------------------------------------------------- /test/integration/bad/new/while-bad2.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/while-bad2.stan -------------------------------------------------------------------------------- /test/integration/bad/new/while-bad3.stan: -------------------------------------------------------------------------------- 1 | transformed data { while (T) void -------------------------------------------------------------------------------- /test/integration/bad/new/while-bad4.stan: -------------------------------------------------------------------------------- 1 | transformed data { while (T~ -------------------------------------------------------------------------------- /test/integration/bad/new/while-bad5.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/while-bad5.stan -------------------------------------------------------------------------------- /test/integration/bad/new/while-bad6.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/new/while-bad6.stan -------------------------------------------------------------------------------- /test/integration/bad/numeric-literal/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/numeric-literal/int-bad1.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | int n = 10_000_; 3 | } -------------------------------------------------------------------------------- /test/integration/bad/numeric-literal/int-bad2.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | int n = 10__000; 3 | } -------------------------------------------------------------------------------- /test/integration/bad/numeric-literal/int-bad4.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | int n = 2_147_483_648; 3 | } -------------------------------------------------------------------------------- /test/integration/bad/numeric-literal/int-bad6.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | int n = -2147483648; 3 | } -------------------------------------------------------------------------------- /test/integration/bad/numeric-literal/real-bad1.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | real x = .e+44; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/numeric-literal/real-bad2.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | real x = 12_.345; 3 | } -------------------------------------------------------------------------------- /test/integration/bad/numeric-literal/real-bad3.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | real x = 12._345; 3 | } -------------------------------------------------------------------------------- /test/integration/bad/numeric-literal/real-bad4.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | real x = 12.345_; 3 | } -------------------------------------------------------------------------------- /test/integration/bad/numeric-literal/real-bad5.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | real x = 12.3_e+10; 3 | } -------------------------------------------------------------------------------- /test/integration/bad/numeric-literal/real-bad6.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | real x = 12.3e+10_; 3 | } -------------------------------------------------------------------------------- /test/integration/bad/ode/adams/dune: -------------------------------------------------------------------------------- 1 | (include ../../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/ode/bad_t_type.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/ode/bad_t_type.stan -------------------------------------------------------------------------------- /test/integration/bad/ode/bad_ts_type.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/ode/bad_ts_type.stan -------------------------------------------------------------------------------- /test/integration/bad/ode/bad_x_type.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/ode/bad_x_type.stan -------------------------------------------------------------------------------- /test/integration/bad/ode/bad_y_type.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/ode/bad_y_type.stan -------------------------------------------------------------------------------- /test/integration/bad/ode/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/ode/stanc.expected: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/ode/stanc.expected -------------------------------------------------------------------------------- /test/integration/bad/oneline-error.stan: -------------------------------------------------------------------------------- 1 | parameters { vector y[10]; } model { } -------------------------------------------------------------------------------- /test/integration/bad/op_addition_bad.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/op_addition_bad.stan -------------------------------------------------------------------------------- /test/integration/bad/op_divide_bad.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/op_divide_bad.stan -------------------------------------------------------------------------------- /test/integration/bad/op_modulus_bad.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/op_modulus_bad.stan -------------------------------------------------------------------------------- /test/integration/bad/print-bad.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/print-bad.stan -------------------------------------------------------------------------------- /test/integration/bad/print-void.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/print-void.stan -------------------------------------------------------------------------------- /test/integration/bad/profiling/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/profiling/profile-bad5.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | real profile; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/real-pdf.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/real-pdf.stan -------------------------------------------------------------------------------- /test/integration/bad/real-pmf.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/real-pmf.stan -------------------------------------------------------------------------------- /test/integration/bad/real_idx.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/real_idx.stan -------------------------------------------------------------------------------- /test/integration/bad/reduce_sum/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/removed_features/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/auto.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real auto; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/break.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/reserved/break.stan -------------------------------------------------------------------------------- /test/integration/bad/reserved/cholesky_factor_corr.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real cholesky_factor_corr; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/cholesky_factor_cov.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real cholesky_factor_cov; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/column_stochastic_matrix.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real column_stochastic_matrix; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/continue.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real continue; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/corr_matrix.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real corr_matrix; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/cov_matrix.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real cov_matrix; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/data.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/reserved/data.stan -------------------------------------------------------------------------------- /test/integration/bad/reserved/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/else.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real else; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/export.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real export; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/extern.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real extern; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/false.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real false; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/for.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real for; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/generated.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real generated; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/if.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real if; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/in.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real in; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/int.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real int; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/matrix.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real matrix; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/model.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/reserved/model.stan -------------------------------------------------------------------------------- /test/integration/bad/reserved/ordered.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real ordered; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/parameters.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real parameters; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/positive_ordered.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real positive_ordered; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/quantities.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real quantities; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/real.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/reserved/real.stan -------------------------------------------------------------------------------- /test/integration/bad/reserved/repeat.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/reserved/repeat.stan -------------------------------------------------------------------------------- /test/integration/bad/reserved/return.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/reserved/return.stan -------------------------------------------------------------------------------- /test/integration/bad/reserved/row_stochastic_matrix.stan: -------------------------------------------------------------------------------- 1 | generated quantities { 2 | int row_stochastic_matrix; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/row_vector.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real row_vector; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/simplex.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real simplex; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/static.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real static; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/struct.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real struct; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/sum_to_zero_matrix.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real sum_to_zero_matrix; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/sum_to_zero_vector.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real sum_to_zero_vector; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/then.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real then; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/transformed.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real transformed; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/true.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real true; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/typedef.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real typedef; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/unit_vector.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real unit_vector; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/until.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real until; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/var.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real var; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/vector.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real vector; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/void.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real void; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/reserved/while.stan: -------------------------------------------------------------------------------- 1 | data { 2 | real while; 3 | } 4 | model { 5 | } 6 | -------------------------------------------------------------------------------- /test/integration/bad/rng-no-suffix.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/rng-no-suffix.stan -------------------------------------------------------------------------------- /test/integration/bad/rng_loc1.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/rng_loc1.stan -------------------------------------------------------------------------------- /test/integration/bad/rng_loc2.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/rng_loc2.stan -------------------------------------------------------------------------------- /test/integration/bad/rng_loc3.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/rng_loc3.stan -------------------------------------------------------------------------------- /test/integration/bad/rng_loc4.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/rng_loc4.stan -------------------------------------------------------------------------------- /test/integration/bad/rng_loc5.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/rng_loc5.stan -------------------------------------------------------------------------------- /test/integration/bad/rng_loc6.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/rng_loc6.stan -------------------------------------------------------------------------------- /test/integration/bad/shadow.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/shadow.stan -------------------------------------------------------------------------------- /test/integration/bad/stanc.expected: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/stanc.expected -------------------------------------------------------------------------------- /test/integration/bad/stanc_helper.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/stanc_helper.stan -------------------------------------------------------------------------------- /test/integration/bad/tabs_error_line.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/tabs_error_line.stan -------------------------------------------------------------------------------- /test/integration/bad/target-reserved.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/target-reserved.stan -------------------------------------------------------------------------------- /test/integration/bad/target_pe_bad.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/target_pe_bad.stan -------------------------------------------------------------------------------- /test/integration/bad/tilde-bad.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/tilde-bad.stan -------------------------------------------------------------------------------- /test/integration/bad/truncation-bad-type1.stan: -------------------------------------------------------------------------------- 1 | model { 1 ~ bernoulli(0.2) T[1, 1.0]; } -------------------------------------------------------------------------------- /test/integration/bad/truncation-bad-type2.stan: -------------------------------------------------------------------------------- 1 | model { 1 ~ bernoulli(0.2) T[0.0, 1]; } -------------------------------------------------------------------------------- /test/integration/bad/truncation-bad-type3.stan: -------------------------------------------------------------------------------- 1 | model { 1 ~ bernoulli(0.2) T[, 1.0]; } -------------------------------------------------------------------------------- /test/integration/bad/truncation-bad-type4.stan: -------------------------------------------------------------------------------- 1 | model { 1 ~ bernoulli(0.2) T[0.0, ]; } -------------------------------------------------------------------------------- /test/integration/bad/tuples/bad-arg.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/tuples/bad-arg.stan -------------------------------------------------------------------------------- /test/integration/bad/tuples/bad-index1.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | real x = 3.4; 3 | print(x.1); 4 | } 5 | -------------------------------------------------------------------------------- /test/integration/bad/tuples/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/tuples/empty_tuple_type.stan: -------------------------------------------------------------------------------- 1 | model { 2 | tuple() y = (); 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/tuples/incomplete1.stan: -------------------------------------------------------------------------------- 1 | data { 2 | tuple( array [ foo ] real , while 3 | -------------------------------------------------------------------------------- /test/integration/bad/tuples/incomplete5.stan: -------------------------------------------------------------------------------- 1 | data { tuple( while 2 | -------------------------------------------------------------------------------- /test/integration/bad/tuples/incomplete6.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | tuple(real, int) x = (3.5, 4; 3 | -------------------------------------------------------------------------------- /test/integration/bad/tuples/incomplete7.stan: -------------------------------------------------------------------------------- 1 | functions { 2 | tuple(real, int, ) foo() 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/tuples/onepl_expr.stan: -------------------------------------------------------------------------------- 1 | model { 2 | print((3.5,)); 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/tuples/onepl_type2.stan: -------------------------------------------------------------------------------- 1 | model { 2 | tuple(real,) x; 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/tuples/onepl_type_missing_comma.stan: -------------------------------------------------------------------------------- 1 | model { 2 | tuple(real) y = (1,); 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/bad/typo.stan: -------------------------------------------------------------------------------- 1 | transformed data { 2 | vector[3] x = to_vetor({1,2,3}); 3 | } -------------------------------------------------------------------------------- /test/integration/bad/unnormalized/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/var-decl-bad-1.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/var-decl-bad-1.stan -------------------------------------------------------------------------------- /test/integration/bad/var-decl-bad-2.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/bad/var-decl-bad-2.stan -------------------------------------------------------------------------------- /test/integration/bad/variadic_dae/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/bad/variadic_ode/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/cli-args/canonicalize/include/first.stanfunctions: -------------------------------------------------------------------------------- 1 | #include second.stanfunctions 2 | -------------------------------------------------------------------------------- /test/integration/cli-args/canonicalize/include/statements2.inc: -------------------------------------------------------------------------------- 1 | /* block comment */ 2 | 3 | foo(3.4); 4 | -------------------------------------------------------------------------------- /test/integration/cli-args/debug-flags.t/parse_error.stan: -------------------------------------------------------------------------------- 1 | datta {} 2 | -------------------------------------------------------------------------------- /test/integration/cli-args/debug-generation.t/incomplete_data.json: -------------------------------------------------------------------------------- 1 | { 2 | "K": 14 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/cli-args/debug-generation.t/partial-div0.json: -------------------------------------------------------------------------------- 1 | { 2 | "M": 0 3 | } 4 | -------------------------------------------------------------------------------- /test/integration/cli-args/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/cli-args/dune -------------------------------------------------------------------------------- /test/integration/cli-args/filename-in-msg/also_empty.stan: -------------------------------------------------------------------------------- 1 | 2 | // nothing here either! 3 | -------------------------------------------------------------------------------- /test/integration/cli-args/filename-in-msg/filename_syntax_error.stan: -------------------------------------------------------------------------------- 1 | model { 2 | rea x = 3; 3 | -------------------------------------------------------------------------------- /test/integration/cli-args/filename-in-msg/includes.stan: -------------------------------------------------------------------------------- 1 | 2 | data { 3 | 4 | } 5 | 6 | #include "filename_syntax_error.stan" 7 | -------------------------------------------------------------------------------- /test/integration/cli-args/info/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/cli-args/info/dune -------------------------------------------------------------------------------- /test/integration/cli-args/info/included.stan: -------------------------------------------------------------------------------- 1 | // nothing here 2 | -------------------------------------------------------------------------------- /test/integration/cli-args/info/includes/another_include.stan: -------------------------------------------------------------------------------- 1 | // nothing here either 2 | -------------------------------------------------------------------------------- /test/integration/cli-args/info/info.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/cli-args/info/info.stan -------------------------------------------------------------------------------- /test/integration/cli-args/model-name/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/cli-args/model-name/dune -------------------------------------------------------------------------------- /test/integration/cli-args/stanc.t: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/cli-args/stanc.t -------------------------------------------------------------------------------- /test/integration/downstream/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/downstream/dune -------------------------------------------------------------------------------- /test/integration/downstream/prophet.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/downstream/prophet.stan -------------------------------------------------------------------------------- /test/integration/downstream/rstanarm/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/downstream/rstanarm/dune -------------------------------------------------------------------------------- /test/integration/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/dune -------------------------------------------------------------------------------- /test/integration/good/array-expr/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/assignment-new.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/assignment-new.stan -------------------------------------------------------------------------------- /test/integration/good/assignments.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/assignments.stan -------------------------------------------------------------------------------- /test/integration/good/break-continue.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/break-continue.stan -------------------------------------------------------------------------------- /test/integration/good/code-gen/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/code-gen/dune -------------------------------------------------------------------------------- /test/integration/good/code-gen/ode/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/code-gen/ode/dune -------------------------------------------------------------------------------- /test/integration/good/comments.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/comments.stan -------------------------------------------------------------------------------- /test/integration/good/compiler-optimizations/pretty.expected: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /test/integration/good/compound-assign/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/dae_good.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/dae_good.stan -------------------------------------------------------------------------------- /test/integration/good/decl_assign.stan: -------------------------------------------------------------------------------- 1 | parameters { 2 | vector[10] xx_param; 3 | } -------------------------------------------------------------------------------- /test/integration/good/declarations.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/declarations.stan -------------------------------------------------------------------------------- /test/integration/good/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/dune -------------------------------------------------------------------------------- /test/integration/good/for_loops/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/fun-defs-lpdf.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/fun-defs-lpdf.stan -------------------------------------------------------------------------------- /test/integration/good/fun-return-typ1.stan: -------------------------------------------------------------------------------- 1 | functions { 2 | real foo() { reject("");} 3 | } -------------------------------------------------------------------------------- /test/integration/good/fun_args_0.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/fun_args_0.stan -------------------------------------------------------------------------------- /test/integration/good/fun_args_0_lp.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/fun_args_0_lp.stan -------------------------------------------------------------------------------- /test/integration/good/fun_args_1.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/fun_args_1.stan -------------------------------------------------------------------------------- /test/integration/good/fun_args_4.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/fun_args_4.stan -------------------------------------------------------------------------------- /test/integration/good/fun_args_4_lp.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/fun_args_4_lp.stan -------------------------------------------------------------------------------- /test/integration/good/fun_args_5.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/fun_args_5.stan -------------------------------------------------------------------------------- /test/integration/good/fun_args_5_lp.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/fun_args_5_lp.stan -------------------------------------------------------------------------------- /test/integration/good/fun_args_int0.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/fun_args_int0.stan -------------------------------------------------------------------------------- /test/integration/good/fun_as_stmt.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/fun_as_stmt.stan -------------------------------------------------------------------------------- /test/integration/good/funs1.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/funs1.stan -------------------------------------------------------------------------------- /test/integration/good/funs2.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/funs2.stan -------------------------------------------------------------------------------- /test/integration/good/funs3.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/funs3.stan -------------------------------------------------------------------------------- /test/integration/good/funs4.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/funs4.stan -------------------------------------------------------------------------------- /test/integration/good/funs5.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/funs5.stan -------------------------------------------------------------------------------- /test/integration/good/funs6.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/funs6.stan -------------------------------------------------------------------------------- /test/integration/good/funs7.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/funs7.stan -------------------------------------------------------------------------------- /test/integration/good/good_inf.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/good_inf.stan -------------------------------------------------------------------------------- /test/integration/good/indexing/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/int_fun.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/int_fun.stan -------------------------------------------------------------------------------- /test/integration/good/io_example.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/io_example.stan -------------------------------------------------------------------------------- /test/integration/good/keywords-if.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/keywords-if.stan -------------------------------------------------------------------------------- /test/integration/good/lang/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/lp_in_fun.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/lp_in_fun.stan -------------------------------------------------------------------------------- /test/integration/good/map_rect.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/map_rect.stan -------------------------------------------------------------------------------- /test/integration/good/mat_assign.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/mat_assign.stan -------------------------------------------------------------------------------- /test/integration/good/mcmc/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/mcmc/hmc/dune: -------------------------------------------------------------------------------- 1 | (include ../../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/mcmc/hmc/pretty.expected: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /test/integration/good/mcmc/pretty.expected: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /test/integration/good/model/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/model/valid.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/model/valid.stan -------------------------------------------------------------------------------- /test/integration/good/model2.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/model2.stan -------------------------------------------------------------------------------- /test/integration/good/ode/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/ode_good.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/ode_good.stan -------------------------------------------------------------------------------- /test/integration/good/optimization/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/overloading/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/parser-generator/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/pretty.expected: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/pretty.expected -------------------------------------------------------------------------------- /test/integration/good/print_chars.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/print_chars.stan -------------------------------------------------------------------------------- /test/integration/good/profiling.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/profiling.stan -------------------------------------------------------------------------------- /test/integration/good/promotion/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/promotion/propto.stan: -------------------------------------------------------------------------------- 1 | model { 2 | target += normal_lupdf(1| {0}, 1); 3 | } -------------------------------------------------------------------------------- /test/integration/good/propto-good.stan: -------------------------------------------------------------------------------- 1 | model { 2 | target += normal_lupdf(1 | 0, 1); 3 | } -------------------------------------------------------------------------------- /test/integration/good/rng_loc.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/rng_loc.stan -------------------------------------------------------------------------------- /test/integration/good/runtime_errors/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/services/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/stat_comp_benchmarks_models/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/target.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/target.stan -------------------------------------------------------------------------------- /test/integration/good/target_good.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/target_good.stan -------------------------------------------------------------------------------- /test/integration/good/tuples/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/tuples/dune -------------------------------------------------------------------------------- /test/integration/good/variational/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/vec-expr/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/vector-zero.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/good/vector-zero.stan -------------------------------------------------------------------------------- /test/integration/good/warning/dune: -------------------------------------------------------------------------------- 1 | (include ../dune) 2 | -------------------------------------------------------------------------------- /test/integration/good/warning/empty.stan: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /test/integration/included/badrecurse1.stan: -------------------------------------------------------------------------------- 1 | #include badrecurse1.stan 2 | -------------------------------------------------------------------------------- /test/integration/included/badrecurse2.stan: -------------------------------------------------------------------------------- 1 | #include badrecurse3.stan 2 | -------------------------------------------------------------------------------- /test/integration/included/badrecurse3.stan: -------------------------------------------------------------------------------- 1 | #include badrecurse2.stan 2 | -------------------------------------------------------------------------------- /test/integration/included/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/included/dune -------------------------------------------------------------------------------- /test/integration/included/error_spread_over_files.stan: -------------------------------------------------------------------------------- 1 | w; 2 | -------------------------------------------------------------------------------- /test/integration/included/incl-err.stan: -------------------------------------------------------------------------------- 1 | real z; 2 | #include "I'm not here.stan" -------------------------------------------------------------------------------- /test/integration/included/incl_stanc_helper_lex_error.stan: -------------------------------------------------------------------------------- 1 | real y; 2 | #include lex-err.stan -------------------------------------------------------------------------------- /test/integration/included/incl_stanc_helper_parse_error.stan: -------------------------------------------------------------------------------- 1 | real y; 2 | #include parse-err.stan -------------------------------------------------------------------------------- /test/integration/included/incl_stanc_helper_semantic_error.stan: -------------------------------------------------------------------------------- 1 | real y; 2 | #include sem-err.stan -------------------------------------------------------------------------------- /test/integration/included/lex-err.stan: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/included/lex-err.stan -------------------------------------------------------------------------------- /test/integration/included/sem-err.stan: -------------------------------------------------------------------------------- 1 | real z; 2 | int w; 3 | -------------------------------------------------------------------------------- /test/integration/run_bin_on_args.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/integration/run_bin_on_args.ml -------------------------------------------------------------------------------- /test/stancjs/allow-undefined.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/allow-undefined.js -------------------------------------------------------------------------------- /test/stancjs/auto-format.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/auto-format.js -------------------------------------------------------------------------------- /test/stancjs/bad_inputs.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/bad_inputs.js -------------------------------------------------------------------------------- /test/stancjs/basic.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/basic.js -------------------------------------------------------------------------------- /test/stancjs/canonical.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/canonical.js -------------------------------------------------------------------------------- /test/stancjs/data-generation.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/data-generation.js -------------------------------------------------------------------------------- /test/stancjs/debug.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/debug.js -------------------------------------------------------------------------------- /test/stancjs/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/dune -------------------------------------------------------------------------------- /test/stancjs/filename.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/filename.js -------------------------------------------------------------------------------- /test/stancjs/functions-only.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/functions-only.js -------------------------------------------------------------------------------- /test/stancjs/good_after_bad.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/good_after_bad.js -------------------------------------------------------------------------------- /test/stancjs/includes.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/includes.js -------------------------------------------------------------------------------- /test/stancjs/info.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/info.js -------------------------------------------------------------------------------- /test/stancjs/math_sigs.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/math_sigs.js -------------------------------------------------------------------------------- /test/stancjs/model_name.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/model_name.js -------------------------------------------------------------------------------- /test/stancjs/optimization.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/optimization.js -------------------------------------------------------------------------------- /test/stancjs/pedantic.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/pedantic.js -------------------------------------------------------------------------------- /test/stancjs/removed.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/removed.js -------------------------------------------------------------------------------- /test/stancjs/run_js_on_args.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/run_js_on_args.ml -------------------------------------------------------------------------------- /test/stancjs/stancjs.expected: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/stancjs.expected -------------------------------------------------------------------------------- /test/stancjs/standalone-functions.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/standalone-functions.js -------------------------------------------------------------------------------- /test/stancjs/utils/utils.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/utils/utils.js -------------------------------------------------------------------------------- /test/stancjs/version.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/version.js -------------------------------------------------------------------------------- /test/stancjs/warnings.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/stancjs/warnings.js -------------------------------------------------------------------------------- /test/unit/Ast_to_Mir_tests.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/unit/Ast_to_Mir_tests.ml -------------------------------------------------------------------------------- /test/unit/Dataflow_utils.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/unit/Dataflow_utils.ml -------------------------------------------------------------------------------- /test/unit/Dependence_analysis.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/unit/Dependence_analysis.ml -------------------------------------------------------------------------------- /test/unit/Desugar_test.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/unit/Desugar_test.ml -------------------------------------------------------------------------------- /test/unit/Error_tests.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/unit/Error_tests.ml -------------------------------------------------------------------------------- /test/unit/Factor_graph.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/unit/Factor_graph.ml -------------------------------------------------------------------------------- /test/unit/In_memory_include_tests.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/unit/In_memory_include_tests.ml -------------------------------------------------------------------------------- /test/unit/Optimize.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/unit/Optimize.ml -------------------------------------------------------------------------------- /test/unit/Parse_tests.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/unit/Parse_tests.ml -------------------------------------------------------------------------------- /test/unit/Semantic_check_tests.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/unit/Semantic_check_tests.ml -------------------------------------------------------------------------------- /test/unit/Stan_math_code_gen_tests.ml: -------------------------------------------------------------------------------- 1 | (* TODO proper unit tests or delete file *) 2 | -------------------------------------------------------------------------------- /test/unit/Test_utils.ml: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/unit/Test_utils.ml -------------------------------------------------------------------------------- /test/unit/dune: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/stan-dev/stanc3/HEAD/test/unit/dune --------------------------------------------------------------------------------